Feature/mqttv5 subscriptions server (#1246)

* Add support for RetainHandling.

* Add support for No Local.

* Add support for _SubscriptionIdentifier_.

* Add more Unit Tests.

* Update docs.

Tests/MQTTnet.AspNetCore.Tests/MqttConnectionContextTest.cs

@@ -17,6 +17,7 @@ using MQTTnet.Packets;
 using System.Net;
 using MQTTnet.AspNetCore.Extensions;
 using MQTTnet.Protocol;
+using MQTTnet.Tests.Extensions;
 
 namespace MQTTnet.AspNetCore.Tests
 {

Tests/MQTTnet.Core.Tests/BaseTestClass.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Formatter;
 using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests
@@ -9,12 +10,12 @@ namespace MQTTnet.Tests
     {
         public TestContext TestContext { get; set; }
         
-        protected TestEnvironment CreateTestEnvironment()
+        protected TestEnvironment CreateTestEnvironment(MqttProtocolVersion protocolVersion = MqttProtocolVersion.V311)
         {
-            return new TestEnvironment(TestContext);
+            return new TestEnvironment(TestContext, protocolVersion);
         }
 
-        protected Task LongDelay()
+        protected Task LongTestDelay()
         {
             return Task.Delay(TimeSpan.FromSeconds(1));
         }

Tests/MQTTnet.Core.Tests/Extensions/MqttPacketWriterExtensions.cs

@@ -1,6 +1,7 @@
-using MQTTnet.Protocol;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
 
-namespace MQTTnet.Formatter
+namespace MQTTnet.Tests.Extensions
 {
     public static class MqttPacketWriterExtensions
     {

Tests/MQTTnet.Core.Tests/LowLevelMqttClient_Tests.cs

@@ -36,7 +36,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var factory = new MqttFactory();
                 var lowLevelClient = factory.CreateLowLevelMqttClient();
@@ -52,7 +52,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var factory = new MqttFactory();
                 var lowLevelClient = factory.CreateLowLevelMqttClient();
@@ -73,7 +73,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var factory = new MqttFactory();
                 var lowLevelClient = factory.CreateLowLevelMqttClient();
@@ -97,8 +97,8 @@ namespace MQTTnet.Tests
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
                 testEnvironment.ServerPort = 8364;
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectLowLevelClientAsync(o => o.WithCommunicationTimeout(TimeSpan.Zero));
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectLowLevelClient(o => o.WithCommunicationTimeout(TimeSpan.Zero));
 
                 await Authenticate(client).ConfigureAwait(false);
 

Tests/MQTTnet.Core.Tests/MQTTv5/Client_Tests.cs

@@ -25,10 +25,10 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 // This test can be also executed against "broker.hivemq.com" to validate package format.
-                var client = await testEnvironment.ConnectClientAsync(
+                var client = await testEnvironment.ConnectClient(
                     new MqttClientOptionsBuilder()
                         //.WithTcpServer("broker.hivemq.com")
                         .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
@@ -61,72 +61,13 @@ namespace MQTTnet.Tests.MQTTv5
             }
         }
         
-        [TestMethod]
-        public async Task Connect_With_AssignedClientId()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                string serverConnectedClientId = null;
-                string serverDisconnectedClientId = null;
-                string clientAssignedClientId = null;
-
-                // Arrange server
-                var disconnectedMre = new ManualResetEventSlim();
-                var serverOptions = new MqttServerOptionsBuilder()
-                    .WithConnectionValidator((context) =>
-                    {
-                        if (string.IsNullOrEmpty(context.ClientId))
-                        {
-                            context.AssignedClientIdentifier = "test123";
-                            context.ReasonCode = MqttConnectReasonCode.Success;
-                        }
-                    });
-                await testEnvironment.StartServerAsync(serverOptions);
-                testEnvironment.Server.UseClientConnectedHandler((args) =>
-                {
-                    serverConnectedClientId = args.ClientId;
-                });
-                testEnvironment.Server.UseClientDisconnectedHandler((args) =>
-                {
-                    serverDisconnectedClientId = args.ClientId;
-                    disconnectedMre.Set();
-                });
-
-                // Arrange client
-                var client = testEnvironment.CreateClient();
-                client.UseConnectedHandler((args) =>
-                {
-                    clientAssignedClientId = args.AuthenticateResult.AssignedClientIdentifier;
-                });
-
-                // Act
-                await client.ConnectAsync(new MqttClientOptionsBuilder()
-                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
-                    .WithProtocolVersion(MqttProtocolVersion.V500)
-                    .WithClientId(null)
-                    .Build());
-                await client.DisconnectAsync();
-
-                // Wait for ClientDisconnectedHandler to trigger
-                disconnectedMre.Wait(500);
-
-                // Assert
-                Assert.IsNotNull(serverConnectedClientId);
-                Assert.IsNotNull(serverDisconnectedClientId);
-                Assert.IsNotNull(clientAssignedClientId);
-                Assert.AreEqual("test123", serverConnectedClientId);
-                Assert.AreEqual("test123", serverDisconnectedClientId);
-                Assert.AreEqual("test123", clientAssignedClientId);
-            }
-        }
-
         [TestMethod]
         public async Task Connect()
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
-                await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                await testEnvironment.StartServer();
+                await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500).Build());
             }
         }
 
@@ -135,9 +76,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
                 await client.DisconnectAsync();
             }
         }
@@ -147,10 +88,10 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var client =
-                    await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                    await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var result = await client.SubscribeAsync(new MqttClientSubscribeOptions()
                 {
@@ -173,9 +114,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
                 await client.SubscribeAsync("a");
 
                 var result = await client.UnsubscribeAsync("a");
@@ -191,9 +132,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
                 var result = await client.PublishAsync("a", "b");
                 await client.DisconnectAsync();
 
@@ -206,9 +147,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
                 var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.AtLeastOnce);
                 await client.DisconnectAsync();
 
@@ -221,9 +162,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
                 var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.ExactlyOnce);
                 await client.DisconnectAsync();
 
@@ -236,9 +177,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var applicationMessage = new MqttApplicationMessageBuilder()
                     .WithTopic("Hello")
@@ -265,11 +206,11 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var receivedMessages = new List<MqttApplicationMessageReceivedEventArgs>();
 
-                var client1 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client1"));
+                var client1 = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client1"));
                 client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     lock (receivedMessages)
@@ -280,7 +221,7 @@ namespace MQTTnet.Tests.MQTTv5
 
                 await client1.SubscribeAsync("a");
 
-                var client2 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client2"));
+                var client2 = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client2"));
                 await client2.PublishAsync("a", "b");
 
                 await Task.Delay(500);
@@ -300,9 +241,9 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var receiver = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+                var receiver = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
                 await receiver.SubscribeAsync("#");
 
                 MqttApplicationMessage receivedMessage = null;
@@ -311,7 +252,7 @@ namespace MQTTnet.Tests.MQTTv5
                     receivedMessage = c.ApplicationMessage;
                 });
 
-                var sender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+                var sender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var applicationMessage = new MqttApplicationMessageBuilder()
                     .WithTopic("Hello")

Tests/MQTTnet.Core.Tests/MQTTv5/Server_Tests.cs

@@ -20,17 +20,17 @@ namespace MQTTnet.Tests.MQTTv5
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
 
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage).WithProtocolVersion(MqttProtocolVersion.V500);
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
+                var c2 = await testEnvironment.ConnectClient(clientOptions);
                 c2.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
 
                 await Task.Delay(1000);

Tests/MQTTnet.Core.Tests/ManagedMqttClient_Tests.cs

@@ -60,7 +60,7 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
                 var clientOptions = new MqttClientOptionsBuilder()
@@ -72,7 +72,7 @@ namespace MQTTnet.Tests
                     .WithClientOptions(clientOptions)
                     .Build());
 
-                var recievingClient = await testEnvironment.ConnectClientAsync();
+                var recievingClient = await testEnvironment.ConnectClient();
                 await recievingClient.SubscribeAsync("My/last/will");
 
                 recievingClient.UseApplicationMessageReceivedHandler(context => Interlocked.Increment(ref receivedMessagesCount));
@@ -90,7 +90,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger());
                 var clientOptions = new MqttClientOptionsBuilder()
@@ -120,7 +120,7 @@ namespace MQTTnet.Tests
                 testEnvironment.IgnoreClientLogErrors = true;
                 testEnvironment.IgnoreServerLogErrors = true;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger());
                 var clientOptions = new MqttClientOptionsBuilder()
@@ -185,7 +185,7 @@ namespace MQTTnet.Tests
                 //wait a bit for the subscriptions to become established before the messages are published
                 await Task.Delay(500);
 
-                var sendingClient = await testEnvironment.ConnectClientAsync();
+                var sendingClient = await testEnvironment.ConnectClient();
 
                 async Task PublishMessages()
                 {
@@ -234,7 +234,7 @@ namespace MQTTnet.Tests
             {
                 var managedClient = await CreateManagedClientAsync(testEnvironment);
 
-                var sendingClient = await testEnvironment.ConnectClientAsync();
+                var sendingClient = await testEnvironment.ConnectClient();
 
                 await managedClient.SubscribeAsync("topic");
 
@@ -269,7 +269,7 @@ namespace MQTTnet.Tests
                 // do not depend on the connection check interval anymore
                 var connectionCheckInterval = TimeSpan.FromSeconds(10);
                 var managedClient = await CreateManagedClientAsync(testEnvironment, null, connectionCheckInterval);
-                var sendingClient = await testEnvironment.ConnectClientAsync();
+                var sendingClient = await testEnvironment.ConnectClient();
                  
                 await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true });
 
@@ -292,9 +292,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync().ConfigureAwait(false);
+                await testEnvironment.StartServer().ConfigureAwait(false);
 
-                var sendingClient = await testEnvironment.ConnectClientAsync().ConfigureAwait(false);
+                var sendingClient = await testEnvironment.ConnectClient().ConfigureAwait(false);
                 await sendingClient.PublishAsync(new MqttApplicationMessage
                 {
                     Topic = "topic",
@@ -360,7 +360,7 @@ namespace MQTTnet.Tests
                 testEnvironment.IgnoreClientLogErrors = true;
 
                 var serverOptions = new MqttServerOptionsBuilder();
-                await testEnvironment.StartServerAsync(serverOptions);
+                await testEnvironment.StartServer(serverOptions);
 
                 var options = new MqttClientOptionsBuilder().WithClientId("1").WithKeepAlivePeriod(TimeSpan.FromSeconds(5));
                 
@@ -384,7 +384,7 @@ namespace MQTTnet.Tests
                 await Task.Delay(10000); // over 1.5T
 
                 var option2 = new MqttClientOptionsBuilder().WithClientId("2").WithKeepAlivePeriod(TimeSpan.FromSeconds(10));
-                var sendClient = await testEnvironment.ConnectClientAsync(option2);
+                var sendClient = await testEnvironment.ConnectClient(option2);
                 await sendClient.PublishAsync("aaa", "1");
                 
                 await Task.Delay(3000);
@@ -398,7 +398,7 @@ namespace MQTTnet.Tests
 
             try
             {
-                var sendClient = await testEnvironment.ConnectClientAsync(options);
+                var sendClient = await testEnvironment.ConnectClient(options);
                 sendClient.ApplicationMessageReceivedHandler = new MQTTnet.Client.Receiving.MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     onReceive();
@@ -417,7 +417,7 @@ namespace MQTTnet.Tests
             IMqttClient underlyingClient = null,
             TimeSpan? connectionCheckInterval = null)
         {
-            await testEnvironment.StartServerAsync();
+            await testEnvironment.StartServer();
 
             var clientOptions = new MqttClientOptionsBuilder()
               .WithTcpServer("localhost", testEnvironment.ServerPort);

Tests/MQTTnet.Core.Tests/Mockups/MqttPacketAsserts.cs

@@ -0,0 +1,18 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Tests.Mockups
+{
+    public sealed class MqttPacketAsserts
+    {
+        public void AssertIsConnectPacket(MqttBasePacket packet)
+        {
+            Assert.AreEqual(packet.GetType(), typeof(MqttConnectPacket));
+        }
+        
+        public void AssertIsConnAckPacket(MqttBasePacket packet)
+        {
+            Assert.AreEqual(packet.GetType(), typeof(MqttConnAckPacket));
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Mockups/TestApplicationMessageReceivedHandler.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client.Receiving;
+using MQTTnet.Implementations;
+
+namespace MQTTnet.Tests.Mockups
+{
+    public sealed class TestApplicationMessageReceivedHandler : IMqttApplicationMessageReceivedHandler
+    {
+        readonly List<MqttApplicationMessage> _messageReceivedEventArgs = new List<MqttApplicationMessage>();
+
+        public Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            lock (_messageReceivedEventArgs)
+            {
+                _messageReceivedEventArgs.Add(eventArgs.ApplicationMessage);
+            }
+            
+            return PlatformAbstractionLayer.CompletedTask;
+        }
+
+        public List<MqttApplicationMessage> ReceivedApplicationMessages
+        {
+            get
+            {
+                lock (_messageReceivedEventArgs)
+                {
+                    return _messageReceivedEventArgs.ToList();
+                }
+            }
+        }
+
+        public void AssertReceivedCountEquals(int expectedCount)
+        {
+            lock (_messageReceivedEventArgs)
+            {
+                Assert.AreEqual(expectedCount, _messageReceivedEventArgs.Count);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Mockups/TestClientWrapper.cs

@@ -47,7 +47,7 @@ namespace MQTTnet.Tests.Mockups
             set => Implementation.ApplicationMessageReceivedHandler = value;
         }
 
-        public Task<MqttClientAuthenticateResult> ConnectAsync(IMqttClientOptions options, CancellationToken cancellationToken)
+        public Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options, CancellationToken cancellationToken)
         {
             if (TestContext != null)
             {

Tests/MQTTnet.Core.Tests/Mockups/TestEnvironment.cs

@@ -11,13 +11,14 @@ using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Extensions.Rpc.Options;
+using MQTTnet.Formatter;
 using MQTTnet.LowLevelClient;
 
 namespace MQTTnet.Tests.Mockups
 {
     public sealed class TestEnvironment : IDisposable
     {
-        readonly MqttFactory _mqttFactory = new MqttFactory();
+        readonly MqttProtocolVersion _protocolVersion;
         readonly List<ILowLevelMqttClient> _lowLevelClients = new List<ILowLevelMqttClient>();
         readonly List<IMqttClient> _clients = new List<IMqttClient>();
         readonly List<string> _serverErrors = new List<string>();
@@ -25,6 +26,8 @@ namespace MQTTnet.Tests.Mockups
 
         readonly List<Exception> _exceptions = new List<Exception>();
 
+        public MqttFactory Factory { get; } = new MqttFactory();
+        
         public IMqttServer Server { get; private set; }
 
         public bool IgnoreClientLogErrors { get; set; }
@@ -43,8 +46,9 @@ namespace MQTTnet.Tests.Mockups
         {
         }
 
-        public TestEnvironment(TestContext testContext)
+        public TestEnvironment(TestContext testContext, MqttProtocolVersion protocolVersion = MqttProtocolVersion.V311)
         {
+            _protocolVersion = protocolVersion;
             TestContext = testContext;
 
             ServerLogger.LogMessagePublished += (s, e) =>
@@ -84,24 +88,26 @@ namespace MQTTnet.Tests.Mockups
         {
             lock (_clients)
             {
-                var client = _mqttFactory.CreateMqttClient(ClientLogger);
+                var client = Factory.CreateMqttClient(ClientLogger);
                 _clients.Add(client);
 
                 return new TestClientWrapper(client, TestContext);
             }
         }
 
-        public Task<IMqttClient> ConnectClientAsync()
+        public Task<IMqttClient> ConnectClient()
         {
-            return ConnectClientAsync(new MqttClientOptionsBuilder());
+            return ConnectClient(Factory.CreateClientOptionsBuilder().WithProtocolVersion(_protocolVersion));
         }
 
-        public async Task<IMqttClient> ConnectClientAsync(Action<MqttClientOptionsBuilder> optionsBuilder)
+        public async Task<IMqttClient> ConnectClient(Action<MqttClientOptionsBuilder> optionsBuilder)
         {
             if (optionsBuilder == null) throw new ArgumentNullException(nameof(optionsBuilder));
 
-            var options = new MqttClientOptionsBuilder();
-            options = options.WithTcpServer("localhost", ServerPort);
+            var options = Factory.CreateClientOptionsBuilder()
+                .WithProtocolVersion(_protocolVersion)
+                .WithTcpServer("127.0.0.1", ServerPort);
+            
             optionsBuilder.Invoke(options);
 
             var client = CreateClient();
@@ -110,11 +116,11 @@ namespace MQTTnet.Tests.Mockups
             return client;
         }
         
-        public async Task<IMqttClient> ConnectClientAsync(MqttClientOptionsBuilder options)
+        public async Task<IMqttClient> ConnectClient(MqttClientOptionsBuilder options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            options = options.WithTcpServer("localhost", ServerPort);
+            options = options.WithTcpServer("127.0.0.1", ServerPort);
 
             var client = CreateClient();
             await client.ConnectAsync(options.Build()).ConfigureAwait(false);
@@ -122,7 +128,7 @@ namespace MQTTnet.Tests.Mockups
             return client;
         }
 
-        public async Task<IMqttClient> ConnectClientAsync(IMqttClientOptions options)
+        public async Task<IMqttClient> ConnectClient(IMqttClientOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
@@ -136,19 +142,19 @@ namespace MQTTnet.Tests.Mockups
         {
             lock (_clients)
             {
-                var client = _mqttFactory.CreateLowLevelMqttClient(ClientLogger);
+                var client = Factory.CreateLowLevelMqttClient(ClientLogger);
                 _lowLevelClients.Add(client);
 
                 return client;
             }
         }
         
-        public Task<ILowLevelMqttClient> ConnectLowLevelClientAsync()
+        public Task<ILowLevelMqttClient> ConnectLowLevelClient()
         {
-            return ConnectLowLevelClientAsync(o => { });
+            return ConnectLowLevelClient(o => { });
         }
 
-        public async Task<ILowLevelMqttClient> ConnectLowLevelClientAsync(Action<MqttClientOptionsBuilder> optionsBuilder)
+        public async Task<ILowLevelMqttClient> ConnectLowLevelClient(Action<MqttClientOptionsBuilder> optionsBuilder)
         {
             if (optionsBuilder == null) throw new ArgumentNullException(nameof(optionsBuilder));
 
@@ -162,14 +168,9 @@ namespace MQTTnet.Tests.Mockups
             return client;
         }
         
-        public async Task<IMqttRpcClient> ConnectRpcClientAsync(IMqttRpcClientOptions options)
+        public async Task<IMqttRpcClient> ConnectRpcClient(IMqttRpcClientOptions options)
         {
-            return new MqttRpcClient(await ConnectClientAsync(), options);
-        }
-
-        public Task<IMqttServer> StartServerAsync()
-        {
-            return StartServerAsync(new MqttServerOptionsBuilder());
+            return new MqttRpcClient(await ConnectClient(), options);
         }
 
         public IMqttServer CreateServer()
@@ -179,11 +180,16 @@ namespace MQTTnet.Tests.Mockups
                 throw new InvalidOperationException("Server already started.");
             }
 
-            Server = new TestServerWrapper(_mqttFactory.CreateMqttServer(ServerLogger), TestContext, this);
+            Server = new TestServerWrapper(Factory.CreateMqttServer(ServerLogger), TestContext, this);
             return Server;
         }
+        
+        public Task<IMqttServer> StartServer()
+        {
+            return StartServer(Factory.CreateServerOptionsBuilder());
+        }
 
-        public async Task<IMqttServer> StartServerAsync(MqttServerOptionsBuilder options)
+        public async Task<IMqttServer> StartServer(MqttServerOptionsBuilder options)
         {
             CreateServer();
             
@@ -194,6 +200,36 @@ namespace MQTTnet.Tests.Mockups
 
             return Server;
         }
+        
+        public async Task<IMqttServer> StartServer(Action<MqttServerOptionsBuilder> options)
+        {
+            CreateServer();
+
+            var optionsBuilder = Factory.CreateServerOptionsBuilder();
+            optionsBuilder.WithDefaultEndpointPort(ServerPort);
+            optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);
+            
+            options?.Invoke(optionsBuilder);
+            
+            await Server.StartAsync(optionsBuilder.Build());
+
+            return Server;
+        }
+        
+        public TestApplicationMessageReceivedHandler CreateApplicationMessageHandler(IMqttClient mqttClient)
+        {
+            if (mqttClient == null) throw new ArgumentNullException(nameof(mqttClient));
+
+            var handler = new TestApplicationMessageReceivedHandler();
+            if (mqttClient.ApplicationMessageReceivedHandler != null)
+            {
+                throw new InvalidOperationException("ApplicationMessageReceivedHandler is already set.");
+            }
+
+            mqttClient.ApplicationMessageReceivedHandler = handler;
+            
+            return handler;
+        }
 
         public void ThrowIfLogErrors()
         {

Tests/MQTTnet.Core.Tests/MqttClient_Tests.cs

@@ -31,8 +31,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectLowLevelClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectLowLevelClient();
 
                 var i = 0;
                 server.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c =>
@@ -67,8 +67,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 Assert.IsTrue(client.IsConnected);
                 client.UseDisconnectedHandler(e => Assert.IsTrue(e.ClientWasConnected));
@@ -83,8 +83,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 Assert.IsTrue(client.IsConnected);
                 client.UseDisconnectedHandler(e => Assert.IsTrue(e.ClientWasConnected));
@@ -123,8 +123,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 await client.PingAsync(CancellationToken.None);
             }
@@ -135,8 +135,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 await client.SubscribeAsync("#");
 
@@ -169,9 +169,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
-                var client1 = await testEnvironment.ConnectClientAsync();
-                var client2 = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var client1 = await testEnvironment.ConnectClient();
+                var client2 = await testEnvironment.ConnectClient();
 
                 await client1.SubscribeAsync("#");
                 await client2.SubscribeAsync("#");
@@ -214,8 +214,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 await Task.Delay(500);
                 Assert.IsTrue(client.IsConnected);
@@ -239,8 +239,8 @@ namespace MQTTnet.Tests
             {
                 testEnvironment.IgnoreClientLogErrors = true;
 
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 await Task.Delay(500);
                 Assert.IsTrue(client.IsConnected);
@@ -314,8 +314,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 var result = await client.PublishAsync("a", "a", MqttQualityOfServiceLevel.AtMostOnce);
                 Assert.AreEqual(null, result.PacketIdentifier);
@@ -393,8 +393,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                var server = await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
 
                 var handlerFired = false;
                 client.UseDisconnectedHandler(e => handlerFired = true);
@@ -445,9 +445,9 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 await client1.SubscribeAsync("x");
 
                 var receivedValues = new List<int>();
@@ -465,7 +465,7 @@ namespace MQTTnet.Tests
 
                 client1.UseApplicationMessageReceivedHandler(Handler1);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 for (var i = MessagesCount; i > 0; i--)
                 {
                     await client2.PublishAsync("x", i.ToString());
@@ -490,9 +490,9 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 await client1.SubscribeAsync("x", MqttQualityOfServiceLevel.ExactlyOnce);
 
                 var receivedValues = new List<int>();
@@ -514,7 +514,7 @@ namespace MQTTnet.Tests
 
                 client1.UseApplicationMessageReceivedHandler(Handler1);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 for (var i = MessagesCount; i > 0; i--)
                 {
                     await client2.PublishAsync("x", i.ToString(), MqttQualityOfServiceLevel.ExactlyOnce);
@@ -534,9 +534,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 await client1.SubscribeAsync("request/+");
 
                 async Task Handler1(MqttApplicationMessageReceivedEventArgs eventArgs)
@@ -546,7 +546,7 @@ namespace MQTTnet.Tests
 
                 client1.UseApplicationMessageReceivedHandler(Handler1);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 await client2.SubscribeAsync("reply/#");
 
                 var replies = new List<string>();
@@ -578,11 +578,11 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var receivedMessages = new List<MqttApplicationMessage>();
 
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 client1.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
@@ -593,7 +593,7 @@ namespace MQTTnet.Tests
 
                 await client1.SubscribeAsync("a");
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithRetainFlag().Build();
                 await client2.PublishAsync(message);
 
@@ -609,13 +609,13 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 const string client1Topic = "client1/topic";
                 const string client2Topic = "client2/topic";
                 const string expectedClient2Message = "hello client2";
 
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 client1.UseApplicationMessageReceivedHandler(async c =>
                 {
                     await client1.PublishAsync(client2Topic, expectedClient2Message, MqttQualityOfServiceLevel.AtLeastOnce);
@@ -623,7 +623,7 @@ namespace MQTTnet.Tests
 
                 await client1.SubscribeAsync(client1Topic, MqttQualityOfServiceLevel.AtLeastOnce);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
 
                 var client2TopicResults = new List<string>();
 
@@ -634,7 +634,7 @@ namespace MQTTnet.Tests
 
                 await client2.SubscribeAsync(client2Topic);
 
-                var client3 = await testEnvironment.ConnectClientAsync();
+                var client3 = await testEnvironment.ConnectClient();
                 var message = new MqttApplicationMessageBuilder().WithTopic(client1Topic).Build();
                 await client3.PublishAsync(message);
                 await client3.PublishAsync(message);
@@ -652,7 +652,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var receivedMessages = new List<MqttApplicationMessage>();
 
@@ -694,12 +694,12 @@ namespace MQTTnet.Tests
                 testEnvironment.IgnoreClientLogErrors = true;
                 testEnvironment.IgnoreServerLogErrors = true;
 
-                await testEnvironment.StartServerAsync(
+                await testEnvironment.StartServer(
                     new MqttServerOptionsBuilder()
                         .WithPersistentSessions()
                         .WithDefaultCommunicationTimeout(TimeSpan.FromMilliseconds(250)));
 
-                var client1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithCleanSession(false));
+                var client1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithCleanSession(false));
                 await client1.SubscribeAsync("x", MqttQualityOfServiceLevel.AtLeastOnce);
 
                 var retries = 0;
@@ -714,7 +714,7 @@ namespace MQTTnet.Tests
 
                 client1.UseApplicationMessageReceivedHandler(Handler1);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 await client2.PublishAsync("x");
 
                 await Task.Delay(3000);
@@ -735,9 +735,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
 
                 Assert.IsTrue(client.IsConnected);
             }
@@ -748,8 +748,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var client = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var client = await testEnvironment.ConnectClient();
                 Assert.IsTrue(client.IsConnected);
 
                 await client.DisconnectAsync();
@@ -763,12 +763,12 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var clients = new List<IMqttClient>();
                 for (var i = 0; i < 100; i++)
                 {
-                    clients.Add(await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("a")));
+                    clients.Add(await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("a")));
                 }
 
                 await Task.Delay(500);
@@ -795,7 +795,7 @@ namespace MQTTnet.Tests
 
                 await receiveClient.SubscribeAsync("x");
 
-                var sendClient = await testEnvironment.ConnectClientAsync();
+                var sendClient = await testEnvironment.ConnectClient();
                 await sendClient.PublishAsync("x", "1");
 
                 await Task.Delay(250);
@@ -809,10 +809,10 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var sender = await testEnvironment.ConnectClientAsync();
-                var receiver = await testEnvironment.ConnectClientAsync();
+                var sender = await testEnvironment.ConnectClient();
+                var receiver = await testEnvironment.ConnectClient();
 
                 var message = new MqttApplicationMessageBuilder()
                     .WithTopic("A");
@@ -840,9 +840,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
-                var client1 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
-                var client2 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                await testEnvironment.StartServer();
+                var client1 = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
+                var client2 = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var disconnectedFired = false;
                 client1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(c =>

Tests/MQTTnet.Core.Tests/MqttPacketSerializer_Tests.cs

@@ -14,6 +14,7 @@ using MQTTnet.Formatter.V5;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Tests.Extensions;
 
 namespace MQTTnet.Tests
 {

Tests/MQTTnet.Core.Tests/RPC_Tests.cs

@@ -62,9 +62,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
                 
-                var requestSender = await testEnvironment.ConnectClientAsync();
+                var requestSender = await testEnvironment.ConnectClient();
 
                 var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build());
                 await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
@@ -77,11 +77,11 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var requestSender = await testEnvironment.ConnectClientAsync();
+                var requestSender = await testEnvironment.ConnectClient();
 
-                var rpcClient = await testEnvironment.ConnectRpcClientAsync(new MqttRpcClientOptionsBuilder().WithTopicGenerationStrategy(new TestTopicStrategy()) .Build());
+                var rpcClient = await testEnvironment.ConnectRpcClient(new MqttRpcClientOptionsBuilder().WithTopicGenerationStrategy(new TestTopicStrategy()) .Build());
                 
                 await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
             }
@@ -91,8 +91,8 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var responseSender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(protocolVersion));
+                await testEnvironment.StartServer();
+                var responseSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(protocolVersion));
                 await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", qosLevel);
 
                 responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
@@ -100,7 +100,7 @@ namespace MQTTnet.Tests
                     await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
                 });
 
-                var requestSender = await testEnvironment.ConnectClientAsync();
+                var requestSender = await testEnvironment.ConnectClient();
 
                 using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
                 {

Tests/MQTTnet.Core.Tests/RoundtripTime_Tests.cs

@@ -18,9 +18,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
-                var receiverClient = await testEnvironment.ConnectClientAsync();
-                var senderClient = await testEnvironment.ConnectClientAsync();
+                await testEnvironment.StartServer();
+                var receiverClient = await testEnvironment.ConnectClient();
+                var senderClient = await testEnvironment.ConnectClient();
 
                 await receiverClient.SubscribeAsync("#");
                 

Tests/MQTTnet.Core.Tests/Server/Assigned_Client_ID_Tests.cs

@@ -0,0 +1,85 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Client.Options;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Assigned_Client_ID_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public Task Connect_With_No_Client_Id()
+        {
+            return Connect_With_Client_Id("test_123", "test_123", null, "test_123");
+        }
+
+        [TestMethod]
+        public Task Connect_With_Client_Id()
+        {
+            return Connect_With_Client_Id("Connect_With_Client_Idtest_456", null, "test_456", null);
+        }
+
+        async Task Connect_With_Client_Id(string expectedClientId, string expectedReturnedClientId, string usedClientId, string assignedClientId)
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                string serverConnectedClientId = null;
+                string serverDisconnectedClientId = null;
+                string clientAssignedClientId = null;
+
+                // Arrange server
+                var disconnectedMre = new ManualResetEventSlim();
+                var serverOptions = new MqttServerOptionsBuilder()
+                    .WithConnectionValidator(context =>
+                    {
+                        if (string.IsNullOrEmpty(context.ClientId))
+                        {
+                            context.AssignedClientIdentifier = assignedClientId;
+                            context.ReasonCode = MqttConnectReasonCode.Success;
+                        }
+                    });
+
+                await testEnvironment.StartServer(serverOptions);
+                testEnvironment.Server.UseClientConnectedHandler(args =>
+                {
+                    serverConnectedClientId = args.ClientId;
+                });
+
+                testEnvironment.Server.UseClientDisconnectedHandler(args =>
+                {
+                    serverDisconnectedClientId = args.ClientId;
+                    disconnectedMre.Set();
+                });
+
+                // Arrange client
+                var client = testEnvironment.CreateClient();
+                client.UseConnectedHandler(args =>
+                {
+                    clientAssignedClientId = args.ConnectResult.AssignedClientIdentifier;
+                });
+
+                // Act
+                await client.ConnectAsync(new MqttClientOptionsBuilder()
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithClientId(usedClientId)
+                    .Build());
+
+                await client.DisconnectAsync();
+
+                // Wait for ClientDisconnectedHandler to trigger
+                disconnectedMre.Wait(1000);
+
+                // Assert
+                Assert.AreEqual(expectedClientId, serverConnectedClientId);
+                Assert.AreEqual(expectedClientId, serverDisconnectedClientId);
+                Assert.AreEqual(expectedReturnedClientId, clientAssignedClientId);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Connection_Tests.cs

@@ -6,19 +6,18 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Implementations;
 using MQTTnet.Server;
-using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public sealed class Server_Connection_Tests
+    public sealed class Connection_Tests : BaseTestClass
     {
         [TestMethod]
         public async Task Close_Idle_Connection_On_Connect()
         {
-            using (var testEnvironment = new TestEnvironment())
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(1)));
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(1)));
 
                 var client = new CrossPlatformSocket(AddressFamily.InterNetwork);
                 await client.ConnectAsync("localhost", testEnvironment.ServerPort, CancellationToken.None);
@@ -45,9 +44,9 @@ namespace MQTTnet.Tests
         [TestMethod]
         public async Task Send_Garbage()
         {
-            using (var testEnvironment = new TestEnvironment())
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(1)));
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(1)));
 
                 // Send an invalid packet and ensure that the server will close the connection and stay in a waiting state
                 // forever. This is security related.

Tests/MQTTnet.Core.Tests/Server/Events_Tests.cs

@@ -7,17 +7,17 @@ using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public sealed class Server_Events_Tests : BaseTestClass
+    public sealed class Events_Tests : BaseTestClass
     {
         [TestMethod]
         public async Task Fire_Client_Connected_Event()
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 MqttServerClientConnectedEventArgs eventArgs = null;
                 server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e =>
@@ -25,14 +25,14 @@ namespace MQTTnet.Tests
                     eventArgs = e;
                 });
 
-                await testEnvironment.ConnectClientAsync(o => o.WithCredentials("TheUser"));
+                await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));
                 
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
                 
                 Assert.IsTrue(eventArgs.ClientId.StartsWith(nameof(Fire_Client_Connected_Event)));
-                Assert.IsTrue(eventArgs.Endpoint.Contains("::1"));
+                Assert.IsTrue(eventArgs.Endpoint.Contains("127.0.0.1"));
                 Assert.AreEqual(MqttProtocolVersion.V311, eventArgs.ProtocolVersion);
                 Assert.AreEqual("TheUser", eventArgs.UserName);
             }
@@ -43,7 +43,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 MqttServerClientDisconnectedEventArgs eventArgs = null;
                 server.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e =>
@@ -51,15 +51,15 @@ namespace MQTTnet.Tests
                     eventArgs = e;
                 });
 
-                var client = await testEnvironment.ConnectClientAsync(o => o.WithCredentials("TheUser"));
+                var client = await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));
                 await client.DisconnectAsync();
                 
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
                 
                 Assert.IsTrue(eventArgs.ClientId.StartsWith(nameof(Fire_Client_Disconnected_Event)));
-                Assert.IsTrue(eventArgs.Endpoint.Contains("::1"));
+                Assert.IsTrue(eventArgs.Endpoint.Contains("127.0.0.1"));
                 Assert.AreEqual(MqttClientDisconnectType.Clean, eventArgs.DisconnectType);
             }
         }
@@ -69,7 +69,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 MqttServerClientSubscribedTopicEventArgs eventArgs = null;
                 server.ClientSubscribedTopicHandler = new MqttServerClientSubscribedTopicHandlerDelegate(e =>
@@ -77,10 +77,10 @@ namespace MQTTnet.Tests
                     eventArgs = e;
                 });
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 await client.SubscribeAsync("The/Topic", MqttQualityOfServiceLevel.AtLeastOnce);
                 
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
                 
@@ -95,7 +95,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
         
                 MqttServerClientUnsubscribedTopicEventArgs eventArgs = null;
                 server.ClientUnsubscribedTopicHandler = new MqttServerClientUnsubscribedTopicHandlerDelegate(e =>
@@ -103,10 +103,10 @@ namespace MQTTnet.Tests
                     eventArgs = e;
                 });
         
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 await client.UnsubscribeAsync("The/Topic");
                 
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
                 
@@ -120,7 +120,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
         
                 MqttApplicationMessageReceivedEventArgs eventArgs = null;
                 server.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
@@ -128,10 +128,10 @@ namespace MQTTnet.Tests
                     eventArgs = e;
                 });
         
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 await client.PublishAsync("The_Topic", "The_Payload");
                 
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
                 
@@ -156,7 +156,7 @@ namespace MQTTnet.Tests
 
                 await server.StartAsync(new MqttServerOptionsBuilder().Build());
         
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
             }
@@ -167,7 +167,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
         
                 EventArgs eventArgs = null;
                 server.StoppedHandler = new MqttServerStoppedHandlerDelegate(e =>
@@ -177,7 +177,7 @@ namespace MQTTnet.Tests
 
                 await server.StopAsync();
         
-                await LongDelay();
+                await LongTestDelay();
                 
                 Assert.IsNotNull(eventArgs);
             }

Tests/MQTTnet.Core.Tests/Server/General.cs

@@ -1,3 +1,9 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Client;
@@ -6,23 +12,15 @@ using MQTTnet.Client.Disconnecting;
 using MQTTnet.Client.Options;
 using MQTTnet.Client.Receiving;
 using MQTTnet.Client.Subscribing;
-using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Diagnostics;
-using MQTTnet.Formatter;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public sealed class Server_Tests
+    public sealed class General_Tests
     {
         public TestContext TestContext { get; set; }
 
@@ -34,7 +32,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var client = testEnvironment.CreateClient();
 
@@ -50,37 +48,12 @@ namespace MQTTnet.Tests
             }
         }
 
-        [TestMethod]
-        public async Task Use_Username_Null_Password_Empty()
-        {
-            string username = null;
-            string password = string.Empty;
-
-            using (var testEnvironment = new TestEnvironment())
-            {
-                testEnvironment.IgnoreClientLogErrors = true;
-
-                await testEnvironment.StartServerAsync();
-
-                var client = testEnvironment.CreateClient();
-
-                var clientOptions = new MqttClientOptionsBuilder()
-                    .WithTcpServer("localhost", testEnvironment.ServerPort)
-                    .WithCredentials(username, password)
-                    .Build();
-
-                var ex = await Assert.ThrowsExceptionAsync<MqttConnectingFailedException>(async () => await client.ConnectAsync(clientOptions));
-                Assert.IsInstanceOfType(ex.InnerException, typeof(MqttProtocolViolationException));
-                Assert.AreEqual("Error while authenticating. If the User Name Flag is set to 0, the Password Flag MUST be set to 0 [MQTT-3.1.2-22].", ex.Message, false);
-            }
-        }
-
         [TestMethod]
         public async Task Use_Empty_Client_ID()
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var client = testEnvironment.CreateClient();
 
@@ -137,7 +110,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var client = testEnvironment.CreateClient();
                 var connectResult = await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort).WithCleanSession().Build());
@@ -153,17 +126,17 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").Build();
 
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
+                var c2 = await testEnvironment.ConnectClient(clientOptions);
                 await c2.DisconnectAsync().ConfigureAwait(false);
 
                 await Task.Delay(1000);
@@ -171,7 +144,7 @@ namespace MQTTnet.Tests
                 Assert.AreEqual(0, receivedMessagesCount);
             }
         }
-        
+
         [TestMethod]
         public async Task Will_Message_Do_Not_Send_On_Takeover()
         {
@@ -179,25 +152,25 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
-                
+                await testEnvironment.StartServer();
+
                 // C1 will receive the last will!
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 // C2 has the last will defined.
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").Build();
-                
+
                 var clientOptions = new MqttClientOptionsBuilder()
                     .WithWillMessage(willMessage)
                     .WithClientId("WillOwner");
-                
-                var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
-                
+
+                var c2 = await testEnvironment.ConnectClient(clientOptions);
+
                 // C3 will do the connection takeover.
-                var c3 = await testEnvironment.ConnectClientAsync(clientOptions);
-                
+                var c3 = await testEnvironment.ConnectClient(clientOptions);
+
                 await Task.Delay(1000);
 
                 Assert.AreEqual(0, receivedMessagesCount);
@@ -211,17 +184,17 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
 
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
+                var c2 = await testEnvironment.ConnectClient(clientOptions);
                 c2.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
 
                 await Task.Delay(1000);
@@ -235,7 +208,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithSubscriptionInterceptor(
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithSubscriptionInterceptor(
                     c =>
                     {
                         // Set the topic to "a" regards what the client wants to subscribe.
@@ -245,7 +218,7 @@ namespace MQTTnet.Tests
                 var topicAReceived = false;
                 var topicBReceived = false;
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 client.UseApplicationMessageReceivedHandler(c =>
                 {
                     if (c.ApplicationMessage.Topic == "a")
@@ -276,12 +249,12 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("c1"));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("c1"));
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
-                var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("c2"));
+                var c2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("c2"));
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
                 await c2.PublishAsync(message);
@@ -290,7 +263,7 @@ namespace MQTTnet.Tests
                 Assert.AreEqual(0, receivedMessagesCount);
 
                 var subscribeEventCalled = false;
-                server.ClientSubscribedTopicHandler = new MqttServerClientSubscribedHandlerDelegate(e =>
+                server.ClientSubscribedTopicHandler = new MqttServerClientSubscribedTopicHandlerDelegate(e =>
                 {
                     subscribeEventCalled = e.TopicFilter.Topic == "a" && e.ClientId == c1.Options.ClientId;
                 });
@@ -330,9 +303,9 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
                     .WithTopicFilter("a")
@@ -340,7 +313,7 @@ namespace MQTTnet.Tests
                     .WithTopicFilter("c")
                     .Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync();
+                var c2 = await testEnvironment.ConnectClient();
 
                 await c2.PublishAsync("a");
                 await Task.Delay(100);
@@ -363,9 +336,9 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 var optionsBuilder = new MqttClientSubscribeOptionsBuilder();
@@ -376,7 +349,7 @@ namespace MQTTnet.Tests
 
                 await c1.SubscribeAsync(optionsBuilder.Build()).ConfigureAwait(false);
 
-                var c2 = await testEnvironment.ConnectClientAsync();
+                var c2 = await testEnvironment.ConnectClient();
 
                 var messageBuilder = new MqttApplicationMessageBuilder();
                 for (var i = 0; i < 500; i++)
@@ -399,9 +372,9 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 for (var i = 0; i < 500; i++)
@@ -414,7 +387,7 @@ namespace MQTTnet.Tests
                     await Task.Delay(10);
                 }
 
-                var c2 = await testEnvironment.ConnectClientAsync();
+                var c2 = await testEnvironment.ConnectClient();
 
                 var messageBuilder = new MqttApplicationMessageBuilder();
                 for (var i = 0; i < 500; i++)
@@ -439,9 +412,9 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
                     .WithTopicFilter("a")
@@ -455,7 +428,7 @@ namespace MQTTnet.Tests
                     .WithTopicFilter("c")
                     .Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync();
+                var c2 = await testEnvironment.ConnectClient();
 
                 await c2.PublishAsync("a");
                 await Task.Delay(100);
@@ -476,11 +449,11 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 var receivedMessagesCount = 0;
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 client.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
@@ -501,21 +474,15 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync();
-                var c2 = await testEnvironment.ConnectClientAsync();
-                var c3 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
+                var c2 = await testEnvironment.ConnectClient();
+                var c3 = await testEnvironment.ConnectClient();
 
-                c2.UseApplicationMessageReceivedHandler(c =>
-                {
-                    Interlocked.Increment(ref receivedMessagesCount);
-                });
+                c2.UseApplicationMessageReceivedHandler(c => { Interlocked.Increment(ref receivedMessagesCount); });
 
-                c3.UseApplicationMessageReceivedHandler(c =>
-                {
-                    Interlocked.Increment(ref receivedMessagesCount);
-                });
+                c3.UseApplicationMessageReceivedHandler(c => { Interlocked.Increment(ref receivedMessagesCount); });
 
                 await c2.SubscribeAsync(new MqttTopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce }).ConfigureAwait(false);
                 await c3.SubscribeAsync(new MqttTopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce }).ConfigureAwait(false);
@@ -538,23 +505,20 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
                 var options = new MqttClientOptionsBuilder()
                     .WithCleanSession(false)
                     .WithProtocolVersion(MqttProtocolVersion.V500) // Disconnect reason is only available in MQTT 5+
                     .WithClientId("a");
 
-                var client1 = await testEnvironment.ConnectClientAsync(options);
+                var client1 = await testEnvironment.ConnectClient(options);
                 await Task.Delay(500);
 
                 MqttClientDisconnectReason disconnectReason = MqttClientDisconnectReason.NormalDisconnection;
-                client1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(c =>
-                {
-                    disconnectReason = c.Reason;
-                });
+                client1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(c => { disconnectReason = c.Reason; });
 
-                var client2 = await testEnvironment.ConnectClientAsync(options);
+                var client2 = await testEnvironment.ConnectClient(options);
                 await Task.Delay(500);
 
                 Assert.IsFalse(client1.IsConnected);
@@ -569,15 +533,12 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 var receivedMessages = new List<MqttApplicationMessage>();
 
-                client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
-                {
-                    await client.PublishAsync("Connected");
-                });
+                client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e => { await client.PublishAsync("Connected"); });
 
                 client.UseApplicationMessageReceivedHandler(c =>
                 {
@@ -602,15 +563,15 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                
+                var server = await testEnvironment.StartServer();
+
                 server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(async e =>
                 {
                     // Every client will automatically subscribe to this topic.
                     await server.SubscribeAsync(e.ClientId, "topic1");
                 });
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 var receivedMessages = new List<MqttApplicationMessage>();
 
                 client.UseApplicationMessageReceivedHandler(c =>
@@ -638,11 +599,11 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder());
 
                 var disconnectCalled = 0;
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder());
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder());
                 c1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(e => disconnectCalled++);
 
                 await Task.Delay(100);
@@ -660,7 +621,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder());
 
                 var clientConnectedCalled = 0;
                 var clientDisconnectedCalled = 0;
@@ -668,8 +629,10 @@ namespace MQTTnet.Tests
                 server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(_ => Interlocked.Increment(ref clientConnectedCalled));
                 server.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(_ => Interlocked.Increment(ref clientDisconnectedCalled));
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder());
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder());
 
+                await Task.Delay(1000);
+                
                 Assert.AreEqual(1, clientConnectedCalled);
                 Assert.AreEqual(0, clientDisconnectedCalled);
 
@@ -691,10 +654,10 @@ namespace MQTTnet.Tests
             {
                 bool clientWasConnected;
 
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder());
                 try
                 {
-                    var client = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder());
+                    var client = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder());
 
                     clientWasConnected = true;
 
@@ -720,7 +683,7 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
                 var tasks = new List<Task>();
                 for (var i = 0; i < ClientCount; i++)
@@ -732,7 +695,7 @@ namespace MQTTnet.Tests
                     {
                         try
                         {
-                            using (var client = await testEnvironment2.ConnectClientAsync())
+                            using (var client = await testEnvironment2.ConnectClient())
                             {
                                 // Clear retained message.
                                 await client.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("r" + i2)
@@ -769,164 +732,17 @@ namespace MQTTnet.Tests
             }
         }
 
-        [TestMethod]
-        public async Task Retained_Messages_Flow()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                var retainedMessage = new MqttApplicationMessageBuilder().WithTopic("r").WithPayload("r").WithRetainFlag().Build();
-
-                await testEnvironment.StartServerAsync();
-                var c1 = await testEnvironment.ConnectClientAsync();
-
-                var receivedMessages = 0;
-
-                var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseApplicationMessageReceivedHandler(c =>
-                {
-                    Interlocked.Increment(ref receivedMessages);
-                });
-
-                await c1.PublishAsync(retainedMessage);
-                await c1.DisconnectAsync();
-                await Task.Delay(500);
-
-                for (var i = 0; i < 5; i++)
-                {
-                    await c2.UnsubscribeAsync("r");
-                    await Task.Delay(100);
-                    Assert.AreEqual(i, receivedMessages);
-
-                    await c2.SubscribeAsync("r");
-                    await Task.Delay(100);
-                    Assert.AreEqual(i + 1, receivedMessages);
-                }
-
-                await c2.DisconnectAsync();
-            }
-        }
-
-        [TestMethod]
-        public async Task Receive_No_Retained_Message_After_Subscribe()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                await testEnvironment.StartServerAsync();
-
-                var c1 = await testEnvironment.ConnectClientAsync();
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
-                await c1.DisconnectAsync();
-
-                var receivedMessagesCount = 0;
-
-                var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
-                await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("retained_other").Build());
-
-                await Task.Delay(500);
-
-                Assert.AreEqual(0, receivedMessagesCount);
-            }
-        }
-
-        [TestMethod]
-        public async Task Receive_Retained_Message_After_Subscribe()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                await testEnvironment.StartServerAsync();
-
-                var c1 = await testEnvironment.ConnectClientAsync();
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
-                await c1.DisconnectAsync();
-
-                var receivedMessages = new List<MqttApplicationMessage>();
-
-                var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseApplicationMessageReceivedHandler(c =>
-                {
-                    lock (receivedMessages)
-                    {
-                        receivedMessages.Add(c.ApplicationMessage);
-                    }
-                });
-
-                await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("retained").Build());
-
-                await Task.Delay(500);
-
-                Assert.AreEqual(1, receivedMessages.Count);
-                Assert.IsTrue(receivedMessages.First().Retain);
-            }
-        }
-
-        [TestMethod]
-        public async Task Clear_Retained_Message_With_Empty_Payload()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                var receivedMessagesCount = 0;
-
-                await testEnvironment.StartServerAsync();
-
-                var c1 = await testEnvironment.ConnectClientAsync();
-
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[0]).WithRetainFlag().Build());
-
-                await c1.DisconnectAsync();
-
-                var c2 = await testEnvironment.ConnectClientAsync();
-
-                c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
-
-                await Task.Delay(200);
-                await c2.SubscribeAsync(new MqttTopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
-                await Task.Delay(500);
-
-                Assert.AreEqual(0, receivedMessagesCount);
-            }
-        }
-
-        [TestMethod]
-        public async Task Clear_Retained_Message_With_Null_Payload()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                var receivedMessagesCount = 0;
-
-                await testEnvironment.StartServerAsync();
-
-                var c1 = await testEnvironment.ConnectClientAsync();
-
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
-                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload((byte[])null).WithRetainFlag().Build());
-
-                await c1.DisconnectAsync();
-
-                var c2 = await testEnvironment.ConnectClientAsync();
-
-                c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
-
-                await Task.Delay(200);
-                await c2.SubscribeAsync(new MqttTopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
-                await Task.Delay(500);
-
-                Assert.AreEqual(0, receivedMessagesCount);
-            }
-        }
-
         [TestMethod]
         public async Task Intercept_Application_Message()
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(
+                await testEnvironment.StartServer(
                     new MqttServerOptionsBuilder().WithApplicationMessageInterceptor(
                         c => { c.ApplicationMessage = new MqttApplicationMessage { Topic = "new_topic" }; }));
 
                 string receivedTopic = null;
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 await c1.SubscribeAsync("#");
                 c1.UseApplicationMessageReceivedHandler(a => { receivedTopic = a.ApplicationMessage.Topic; });
 
@@ -944,9 +760,9 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithStorage(serverStorage));
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithStorage(serverStorage));
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
 
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
 
@@ -961,22 +777,19 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
-                server.UseClientConnectedHandler(async e =>
-                {
-                    await server.PublishAsync("/test/1", "true", MqttQualityOfServiceLevel.ExactlyOnce, false);
-                });
+                var server = await testEnvironment.StartServer();
+                server.UseClientConnectedHandler(async e => { await server.PublishAsync("/test/1", "true", MqttQualityOfServiceLevel.ExactlyOnce, false); });
 
                 string receivedTopic = null;
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
                 c1.UseApplicationMessageReceivedHandler(e => { receivedTopic = e.ApplicationMessage.Topic; });
                 await c1.SubscribeAsync("#");
 
-                await testEnvironment.ConnectClientAsync();
-                await testEnvironment.ConnectClientAsync();
-                await testEnvironment.ConnectClientAsync();
-                await testEnvironment.ConnectClientAsync();
+                await testEnvironment.ConnectClient();
+                await testEnvironment.ConnectClient();
+                await testEnvironment.ConnectClient();
+                await testEnvironment.ConnectClient();
 
                 await Task.Delay(500);
 
@@ -994,17 +807,14 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithApplicationMessageInterceptor(Interceptor));
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithApplicationMessageInterceptor(Interceptor));
 
-                var c1 = await testEnvironment.ConnectClientAsync();
-                var c2 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
+                var c2 = await testEnvironment.ConnectClient();
                 await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("test").Build());
 
                 var isIntercepted = false;
-                c2.UseApplicationMessageReceivedHandler(c =>
-                {
-                    isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(c.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
-                });
+                c2.UseApplicationMessageReceivedHandler(c => { isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(c.ApplicationMessage.Payload), StringComparison.Ordinal) == 0; });
 
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("test").Build());
                 await c1.DisconnectAsync();
@@ -1040,17 +850,14 @@ namespace MQTTnet.Tests
 
                 byte[] receivedBody = null;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client1 = await testEnvironment.ConnectClientAsync();
-                client1.UseApplicationMessageReceivedHandler(c =>
-                {
-                    receivedBody = c.ApplicationMessage.Payload;
-                });
+                var client1 = await testEnvironment.ConnectClient();
+                client1.UseApplicationMessageReceivedHandler(c => { receivedBody = c.ApplicationMessage.Payload; });
 
                 await client1.SubscribeAsync("string");
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 await client2.PublishAsync("string", longBody);
 
                 await Task.Delay(TimeSpan.FromSeconds(5));
@@ -1062,18 +869,15 @@ namespace MQTTnet.Tests
         [TestMethod]
         public async Task Deny_Connection()
         {
-            var serverOptions = new MqttServerOptionsBuilder().WithConnectionValidator(context =>
-            {
-                context.ReasonCode = MqttConnectReasonCode.NotAuthorized;
-            });
+            var serverOptions = new MqttServerOptionsBuilder().WithConnectionValidator(context => { context.ReasonCode = MqttConnectReasonCode.NotAuthorized; });
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
                 testEnvironment.IgnoreClientLogErrors = true;
 
-                await testEnvironment.StartServerAsync(serverOptions);
+                await testEnvironment.StartServer(serverOptions);
 
-                var connectingFailedException = await Assert.ThrowsExceptionAsync<MqttConnectingFailedException>(() => testEnvironment.ConnectClientAsync());
+                var connectingFailedException = await Assert.ThrowsExceptionAsync<MqttConnectingFailedException>(() => testEnvironment.ConnectClient());
                 Assert.AreEqual(MqttClientConnectResultCode.NotAuthorized, connectingFailedException.ResultCode);
             }
         }
@@ -1103,7 +907,7 @@ namespace MQTTnet.Tests
                 _connected = new Dictionary<string, bool>();
                 var options = new MqttServerOptionsBuilder();
                 options.WithConnectionValidator(e => ConnectionValidationHandler(e));
-                var server = await testEnvironment.StartServerAsync(options);
+                var server = await testEnvironment.StartServer(options);
 
                 var events = new List<string>();
 
@@ -1127,7 +931,7 @@ namespace MQTTnet.Tests
                     .WithClientId("same_id");
 
                 // c
-                var c1 = await testEnvironment.ConnectClientAsync(clientOptions);
+                var c1 = await testEnvironment.ConnectClient(clientOptions);
 
                 c1.UseDisconnectedHandler(_ =>
                 {
@@ -1144,7 +948,6 @@ namespace MQTTnet.Tests
                     {
                         events.Add("r");
                     }
-
                 });
 
                 c1.SubscribeAsync("topic").Wait();
@@ -1160,7 +963,7 @@ namespace MQTTnet.Tests
 
                 try
                 {
-                    await testEnvironment.ConnectClientAsync(clientOptions);
+                    await testEnvironment.ConnectClient(clientOptions);
                     Assert.Fail("same id connection is expected to fail");
                 }
                 catch
@@ -1187,7 +990,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment())
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder());
 
                 var events = new List<string>();
 
@@ -1211,7 +1014,7 @@ namespace MQTTnet.Tests
                     .WithClientId(Guid.NewGuid().ToString());
 
                 // c
-                var c1 = await testEnvironment.ConnectClientAsync(clientOptionsBuilder);
+                var c1 = await testEnvironment.ConnectClient(clientOptionsBuilder);
 
                 await Task.Delay(500);
 
@@ -1220,7 +1023,7 @@ namespace MQTTnet.Tests
 
                 // dc
                 // Connect client with same client ID. Should disconnect existing client.
-                var c2 = await testEnvironment.ConnectClientAsync(clientOptionsBuilder);
+                var c2 = await testEnvironment.ConnectClient(clientOptionsBuilder);
 
                 await Task.Delay(500);
 
@@ -1272,10 +1075,10 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder());
 
                 var clientOptions = new MqttClientOptionsBuilder();
-                var c1 = await testEnvironment.ConnectClientAsync(clientOptions);
+                var c1 = await testEnvironment.ConnectClient(clientOptions);
                 await Task.Delay(500);
                 Assert.AreEqual(1, (await server.GetClientStatusAsync()).Count);
 
@@ -1293,14 +1096,14 @@ namespace MQTTnet.Tests
             {
                 testEnvironment.IgnoreClientLogErrors = true;
 
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
-                await testEnvironment.ConnectClientAsync();
+                await testEnvironment.ConnectClient();
                 await server.StopAsync();
 
                 try
                 {
-                    await testEnvironment.ConnectClientAsync();
+                    await testEnvironment.ConnectClient();
                     Assert.Fail("Connecting should fail.");
                 }
                 catch (Exception)
@@ -1308,7 +1111,7 @@ namespace MQTTnet.Tests
                 }
 
                 await server.StartAsync(new MqttServerOptionsBuilder().WithDefaultEndpointPort(testEnvironment.ServerPort).Build());
-                await testEnvironment.ConnectClientAsync();
+                await testEnvironment.ConnectClient();
             }
         }
 
@@ -1317,7 +1120,7 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithSubscriptionInterceptor(c =>
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithSubscriptionInterceptor(c =>
                 {
                     // This should lead to no subscriptions for "n" at all. So also no sending of retained messages.
                     if (c.TopicFilter.Topic == "n")
@@ -1327,7 +1130,7 @@ namespace MQTTnet.Tests
                 }));
 
                 // Prepare some retained messages.
-                var client1 = await testEnvironment.ConnectClientAsync();
+                var client1 = await testEnvironment.ConnectClient();
                 await client1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("y").WithPayload("x").WithRetainFlag().Build());
                 await client1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("n").WithPayload("x").WithRetainFlag().Build());
                 await client1.DisconnectAsync();
@@ -1336,7 +1139,7 @@ namespace MQTTnet.Tests
 
                 // Subscribe to all retained message types.
                 // It is important to do this in a range of filters to ensure that a subscription is not "hidden".
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
 
                 var buffer = new StringBuilder();
 
@@ -1361,10 +1164,10 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithPersistentSessions());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithPersistentSessions());
 
                 // Create the session including the subscription.
-                var client1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("a"));
+                var client1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("a"));
                 await client1.SubscribeAsync("x");
                 await client1.DisconnectAsync();
                 await Task.Delay(500);
@@ -1372,7 +1175,7 @@ namespace MQTTnet.Tests
                 var clientStatus = await server.GetClientStatusAsync();
                 Assert.AreEqual(0, clientStatus.Count);
 
-                var client2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("b"));
+                var client2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("b"));
                 await client2.PublishAsync("x", "1");
                 await client2.PublishAsync("x", "2");
                 await client2.PublishAsync("x", "3");
@@ -1402,13 +1205,13 @@ namespace MQTTnet.Tests
             {
                 var receivedMessagesCount = 0;
 
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("receiver"));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("receiver"));
                 c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic(topicFilter).WithQualityOfServiceLevel(filterQualityOfServiceLevel).Build());
 
-                var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("sender"));
+                var c2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("sender"));
                 await c2.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(new byte[0]).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
                 await c2.DisconnectAsync().ConfigureAwait(false);
 
@@ -1428,14 +1231,11 @@ namespace MQTTnet.Tests
                 var undeliverd = string.Empty;
 
                 var options = new MqttServerOptionsBuilder().WithUndeliveredMessageInterceptor(
-                    context =>
-                    {
-                        undeliverd = context.ApplicationMessage.Topic;
-                    });
+                    context => { undeliverd = context.ApplicationMessage.Topic; });
 
-                await testEnvironment.StartServerAsync(options);
+                await testEnvironment.StartServer(options);
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
 
                 await client.SubscribeAsync("b");
 
@@ -1452,13 +1252,13 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder()
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder()
                     .WithClientMessageQueueInterceptor(c => c.ApplicationMessage.Topic = "a"));
 
                 var topicAReceived = false;
                 var topicBReceived = false;
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 client.UseApplicationMessageReceivedHandler(c =>
                 {
                     if (c.ApplicationMessage.Topic == "a")
@@ -1490,15 +1290,12 @@ namespace MQTTnet.Tests
 
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder()
+                await testEnvironment.StartServer(new MqttServerOptionsBuilder()
                     .WithClientMessageQueueInterceptor(c => { })); // Interceptor does nothing but has to be present.
 
                 bool receivedMessage = false;
-                var client = await testEnvironment.ConnectClientAsync();
-                client.UseApplicationMessageReceivedHandler(c =>
-                {
-                    receivedMessage = true;
-                });
+                var client = await testEnvironment.ConnectClient();
+                client.UseApplicationMessageReceivedHandler(c => { receivedMessage = true; });
 
                 await client.SubscribeAsync(topic, MqttQualityOfServiceLevel.AtLeastOnce);
 
@@ -1510,4 +1307,4 @@ namespace MQTTnet.Tests
             }
         }
     }
-}
+}

Tests/MQTTnet.Core.Tests/Server/Keep_Alive_Tests.cs

@@ -5,21 +5,20 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public sealed class Server_KeepAlive_Tests
+    public sealed class KeepAlive_Tests : BaseTestClass
     {
         [TestMethod]
         public async Task Disconnect_Client_DueTo_KeepAlive()
         {
-            using (var testEnvironment = new TestEnvironment())
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var client = await testEnvironment.ConnectLowLevelClientAsync(o => o
+                var client = await testEnvironment.ConnectLowLevelClient(o => o
                     .WithCommunicationTimeout(TimeSpan.FromSeconds(1))
                     .WithCommunicationTimeout(TimeSpan.Zero)
                     .WithProtocolVersion(MqttProtocolVersion.V500)).ConfigureAwait(false);
@@ -27,7 +26,7 @@ namespace MQTTnet.Tests
                 await client.SendAsync(new MqttConnectPacket
                 {
                     CleanSession = true,
-                    ClientId = "abc",
+                    ClientId = "Disconnect_Client_DueTo_KeepAlive",
                     KeepAlivePeriod = 1
                 }, CancellationToken.None).ConfigureAwait(false);
 

Tests/MQTTnet.Core.Tests/Server/MqttSubscriptionsManager_Tests.cs

@@ -1,13 +1,13 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
-using MQTTnet.Tests.Mockups;
-using System.Collections.Concurrent;
-using System.Threading.Tasks;
 using MQTTnet.Server.Internal;
+using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
     public class MqttSubscriptionsManager_Tests
@@ -17,14 +17,14 @@ namespace MQTTnet.Tests
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerEventDispatcher(new TestLogger()), new MqttServerOptions());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventDispatcher(new TestLogger()), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
 
-            await sm.SubscribeAsync(sp, new MqttConnectPacket());
+            await sm.Subscribe(sp);
 
-            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce);
+            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce, "");
             Assert.IsTrue(result.IsSubscribed);
             Assert.AreEqual(result.QualityOfServiceLevel, MqttQualityOfServiceLevel.AtMostOnce);
         }
@@ -34,14 +34,14 @@ namespace MQTTnet.Tests
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerEventDispatcher(new TestLogger()), new MqttServerOptions());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventDispatcher(new TestLogger()), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
 
-            await sm.SubscribeAsync(sp, new MqttConnectPacket());
+            await sm.Subscribe(sp);
 
-            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce);
+            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce, "");
             Assert.IsTrue(result.IsSubscribed);
             Assert.AreEqual(result.QualityOfServiceLevel, MqttQualityOfServiceLevel.AtMostOnce);
         }
@@ -51,15 +51,15 @@ namespace MQTTnet.Tests
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerEventDispatcher(new TestLogger()), new MqttServerOptions());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventDispatcher(new TestLogger()), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilter { Topic = "#", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
             sp.TopicFilters.Add(new MqttTopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
 
-            await sm.SubscribeAsync(sp, new MqttConnectPacket());
+            await sm.Subscribe(sp);
 
-            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce);
+            var result = sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce, "");
             Assert.IsTrue(result.IsSubscribed);
             Assert.AreEqual(result.QualityOfServiceLevel, MqttQualityOfServiceLevel.AtLeastOnce);
         }
@@ -69,14 +69,14 @@ namespace MQTTnet.Tests
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerEventDispatcher(new TestLogger()), new MqttServerOptions());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventDispatcher(new TestLogger()), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
 
-            await sm.SubscribeAsync(sp, new MqttConnectPacket());
+            await sm.Subscribe(sp);
 
-            Assert.IsFalse(sm.CheckSubscriptions("A/B/X", MqttQualityOfServiceLevel.AtMostOnce).IsSubscribed);
+            Assert.IsFalse(sm.CheckSubscriptions("A/B/X", MqttQualityOfServiceLevel.AtMostOnce, "").IsSubscribed);
         }
 
         [TestMethod]
@@ -84,20 +84,20 @@ namespace MQTTnet.Tests
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerEventDispatcher(new TestLogger()), new MqttServerOptions());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventDispatcher(new TestLogger()), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
 
-            await sm.SubscribeAsync(sp, new MqttConnectPacket());
+            await sm.Subscribe(sp);
 
-            Assert.IsTrue(sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce).IsSubscribed);
+            Assert.IsTrue(sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce, "").IsSubscribed);
 
             var up = new MqttUnsubscribePacket();
             up.TopicFilters.Add("A/B/C");
-            await sm.UnsubscribeAsync(up);
+            await sm.Unsubscribe(up);
 
-            Assert.IsFalse(sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce).IsSubscribed);
+            Assert.IsFalse(sm.CheckSubscriptions("A/B/C", MqttQualityOfServiceLevel.AtMostOnce, "").IsSubscribed);
         }
 
         MqttClientSession CreateSession()
@@ -107,8 +107,7 @@ namespace MQTTnet.Tests
                 new ConcurrentDictionary<object, object>(),
                 new MqttServerEventDispatcher(new TestLogger()),
                 new MqttServerOptions(),
-                new MqttRetainedMessagesManager(),
-                new TestLogger());
+                new MqttRetainedMessagesManager());
         }
     }
 }

Tests/MQTTnet.Core.Tests/Server/No_Local_Tests.cs

@@ -0,0 +1,47 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class No_Local_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public Task Subscribe_With_No_Local()
+        {
+            return ExecuteTest(true, 0);
+        }
+        
+        [TestMethod]
+        public Task Subscribe_Without_No_Local()
+        {
+            return ExecuteTest(false, 1);
+        }
+
+        async Task ExecuteTest(
+            bool noLocal,
+            int expectedCountAfterPublish)
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+                
+                var client1 = await testEnvironment.ConnectClient();
+                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client1);
+                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic").WithNoLocal(noLocal).Build();
+                await client1.SubscribeAsync(topicFilter);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(0);
+                
+                // The client will publish a message where it is itself subscribing to.
+                await client1.PublishAsync("Topic", "Payload", true);
+                await LongTestDelay();
+                
+                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterPublish);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Retain_As_Published_Tests.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Formatter;
+using MQTTnet.Client;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Retain_As_Published_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public Task Subscribe_With_Retain_As_Published()
+        {
+            return ExecuteTest(true);
+        }
+
+        [TestMethod]
+        public Task Subscribe_Without_Retain_As_Published()
+        {
+            return ExecuteTest(false);
+        }
+
+        async Task ExecuteTest(bool retainAsPublished)
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var client1 = await testEnvironment.ConnectClient();
+                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client1);
+                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic").WithRetainAsPublished(retainAsPublished).Build();
+                await client1.SubscribeAsync(topicFilter);
+                await LongTestDelay();
+
+                // The client will publish a message where it is itself subscribing to.
+                await client1.PublishAsync("Topic", "Payload", true);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(1);
+                Assert.AreEqual(retainAsPublished, applicationMessageHandler.ReceivedApplicationMessages[0].Retain);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Retain_Handling_Tests.cs

@@ -0,0 +1,66 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Retain_Handling_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public Task Send_At_Subscribe()
+        {
+            return ExecuteTest(MqttRetainHandling.SendAtSubscribe, 1, 2, 3);
+        }
+        
+        [TestMethod]
+        public Task Do_Not_Send_On_Subscribe()
+        {
+            return ExecuteTest(MqttRetainHandling.DoNotSendOnSubscribe, 0, 1, 1);
+        }
+        
+        [TestMethod]
+        public Task Send_At_Subscribe_If_New_Subscription_Only()
+        {
+            return ExecuteTest(MqttRetainHandling.SendAtSubscribeIfNewSubscriptionOnly, 1, 2, 2);
+        }
+
+        async Task ExecuteTest(
+            MqttRetainHandling retainHandling,
+            int expectedCountAfterSubscribe,
+            int expectedCountAfterSecondPublish,
+            int expectedCountAfterSecondSubscribe)
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var client1 = await testEnvironment.ConnectClient();
+                await client1.PublishAsync("Topic", "Payload", true);
+
+                await LongTestDelay();
+                
+                var client2 = await testEnvironment.ConnectClient();
+                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client2);
+                
+                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic").WithRetainHandling(retainHandling).Build();
+                await client2.SubscribeAsync(topicFilter);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSubscribe);
+                
+                await client1.PublishAsync("Topic", "Payload", true);
+                await LongTestDelay();
+                
+                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSecondPublish);
+                
+                await client2.SubscribeAsync(topicFilter);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSecondSubscribe);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Retained_Messages_Tests.cs

@@ -0,0 +1,171 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Retained_Messages_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Server_Reports_Retained_Messages_Supported_V3()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V311)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsTrue(connectResult.RetainAvailable);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Server_Reports_Retained_Messages_Supported_V5()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsTrue(connectResult.RetainAvailable);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Retained_Messages_Flow()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var retainedMessage = new MqttApplicationMessageBuilder().WithTopic("r").WithPayload("r").WithRetainFlag().Build();
+
+                await testEnvironment.StartServer();
+                var c1 = await testEnvironment.ConnectClient();
+    
+                var c2 = await testEnvironment.ConnectClient();
+                var messageHandler = testEnvironment.CreateApplicationMessageHandler(c2);
+                
+                await c1.PublishAsync(retainedMessage);
+                await c1.DisconnectAsync();
+                await LongTestDelay();
+
+                for (var i = 0; i < 5; i++)
+                {
+                    await c2.UnsubscribeAsync("r");
+                    await Task.Delay(100);
+                    messageHandler.AssertReceivedCountEquals(i);
+                    
+                    await c2.SubscribeAsync("r");
+                    await Task.Delay(100);
+                    messageHandler.AssertReceivedCountEquals(i + 1);
+                }
+
+                await c2.DisconnectAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Receive_No_Retained_Message_After_Subscribe()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var c1 = await testEnvironment.ConnectClient();
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
+                await c1.DisconnectAsync();
+
+                var c2 = await testEnvironment.ConnectClient();
+                var messageHandler = testEnvironment.CreateApplicationMessageHandler(c2);
+                await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("retained_other").Build());
+
+                await Task.Delay(500);
+
+                messageHandler.AssertReceivedCountEquals(0);
+            }
+        }
+
+        [TestMethod]
+        public async Task Receive_Retained_Message_After_Subscribe()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var c1 = await testEnvironment.ConnectClient();
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
+                await c1.DisconnectAsync();
+
+                var c2 = await testEnvironment.ConnectClient();
+                var messageHandler = testEnvironment.CreateApplicationMessageHandler(c2);
+                
+                await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("retained").Build());
+
+                await Task.Delay(500);
+
+                messageHandler.AssertReceivedCountEquals(1);
+                Assert.IsTrue(messageHandler.ReceivedApplicationMessages.First().Retain);
+            }
+        }
+
+        [TestMethod]
+        public async Task Clear_Retained_Message_With_Empty_Payload()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var c1 = await testEnvironment.ConnectClient();
+
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[0]).WithRetainFlag().Build());
+
+                await c1.DisconnectAsync();
+
+                var c2 = await testEnvironment.ConnectClient();
+                var messageHandler = testEnvironment.CreateApplicationMessageHandler(c2);
+                
+                await Task.Delay(200);
+                await c2.SubscribeAsync(new MqttTopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
+                await Task.Delay(500);
+
+                messageHandler.AssertReceivedCountEquals(0);
+            }
+        }
+
+        [TestMethod]
+        public async Task Clear_Retained_Message_With_Null_Payload()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var c1 = await testEnvironment.ConnectClient();
+
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
+                await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload((byte[])null).WithRetainFlag().Build());
+
+                await c1.DisconnectAsync();
+
+                var c2 = await testEnvironment.ConnectClient();
+                var messageHandler = testEnvironment.CreateApplicationMessageHandler(c2);
+                
+                await Task.Delay(200);
+                await c2.SubscribeAsync(new MqttTopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
+                await Task.Delay(500);
+
+                messageHandler.AssertReceivedCountEquals(0);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Security_Tests.cs

@@ -0,0 +1,90 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Options;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Security_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Use_Username_Null_Password_Empty()
+        {
+            string username = null;
+            var password = string.Empty;
+
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                testEnvironment.IgnoreClientLogErrors = true;
+
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+
+                var clientOptions = new MqttClientOptionsBuilder()
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                    .WithCredentials(username, password)
+                    .Build();
+
+                var ex = await Assert.ThrowsExceptionAsync<MqttConnectingFailedException>(async () => await client.ConnectAsync(clientOptions));
+                Assert.IsInstanceOfType(ex.InnerException, typeof(MqttProtocolViolationException));
+                Assert.AreEqual("Error while authenticating. If the User Name Flag is set to 0, the Password Flag MUST be set to 0 [MQTT-3.1.2-22].", ex.Message, false);
+            }
+        }
+        
+        [TestMethod]
+        public Task Handle_Wrong_UserName()
+        {
+            return TestCredentials("x", "Password1");
+        }
+        
+        [TestMethod]
+        public Task Handle_Wrong_Password()
+        {
+            return TestCredentials("UserName", "x");
+        }
+        
+        [TestMethod]
+        public Task Handle_Wrong_UserName_And_Password()
+        {
+            return TestCredentials("x", "x");
+        }
+
+        async Task TestCredentials(string userName, string password)
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                testEnvironment.IgnoreClientLogErrors = true;
+
+                await testEnvironment.StartServer(testEnvironment.Factory.CreateServerOptionsBuilder()
+                    .WithConnectionValidator(c =>
+                    {
+                        if (c.Username != "UserName1")
+                        {
+                            c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
+                        }
+                        
+                        if (c.Password != "Password1")
+                        {
+                            c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
+                        }
+                    }));
+
+                var client = testEnvironment.CreateClient();
+
+                var clientOptions = new MqttClientOptionsBuilder()
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                    .WithCredentials(userName, password)
+                    .Build();
+
+                var ex = await Assert.ThrowsExceptionAsync<MqttConnectingFailedException>(async () => await client.ConnectAsync(clientOptions));
+                Assert.AreEqual(ex.Result.ResultCode, MqttClientConnectResultCode.BadUserNameOrPassword);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Server_Reference_Tests.cs

@@ -0,0 +1,50 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Options;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Server_Reference_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Server_Reports_With_Reference_Server()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                testEnvironment.IgnoreClientLogErrors = true;
+                
+                await testEnvironment.StartServer(o =>
+                {
+                    o.WithConnectionValidator(v =>
+                    {
+                        v.ReasonCode = MqttConnectReasonCode.ServerMoved;
+                        v.ServerReference = "new_server";
+                    });
+                });
+
+                try
+                {
+                    var client = testEnvironment.CreateClient();
+                    
+                    await client.ConnectAsync(new MqttClientOptionsBuilder()
+                        .WithProtocolVersion(MqttProtocolVersion.V500)
+                        .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                        .Build());
+                    
+                    Assert.Fail();
+                }
+                catch (MqttConnectingFailedException e)
+                {
+                    Assert.AreEqual(MqttClientConnectResultCode.ServerMoved, e.ResultCode);
+                    Assert.AreEqual("new_server", e.Result.ServerReference);
+                }
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Session_Tests.cs

@@ -1,14 +1,14 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Client.Options;
 using MQTTnet.Client.Subscribing;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
     public class Session_Tests
@@ -39,11 +39,11 @@ namespace MQTTnet.Tests
                         context.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(context.SessionItems["default_payload"] as string);
                     });
 
-                await testEnvironment.StartServerAsync(serverOptions);
+                await testEnvironment.StartServer(serverOptions);
 
                 string receivedPayload = null;
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
                 client.UseApplicationMessageReceivedHandler(delegate (MqttApplicationMessageReceivedEventArgs args)
                 {
                     receivedPayload = args.ApplicationMessage.ConvertPayloadToString();
@@ -53,7 +53,7 @@ namespace MQTTnet.Tests
 
                 Assert.AreEqual(MqttClientSubscribeResultCode.GrantedQoS0, subscribeResult.Items[0].ResultCode);
 
-                var client2 = await testEnvironment.ConnectClientAsync();
+                var client2 = await testEnvironment.ConnectClient();
                 await client2.PublishAsync("x");
 
                 await Task.Delay(1000);
@@ -75,9 +75,9 @@ namespace MQTTnet.Tests
                         context.SessionItems["default_payload"] = "Hello World";
                     });
 
-                await testEnvironment.StartServerAsync(serverOptions);
+                await testEnvironment.StartServer(serverOptions);
 
-                var client = await testEnvironment.ConnectClientAsync();
+                var client = await testEnvironment.ConnectClient();
 
                 var sessionStatus = await testEnvironment.Server.GetSessionStatusAsync();
                 var session = sessionStatus.First();
@@ -94,7 +94,7 @@ namespace MQTTnet.Tests
             {
                 testEnvironment.IgnoreClientLogErrors = true;
                 var serverOptions = new MqttServerOptionsBuilder();
-                await testEnvironment.StartServerAsync(serverOptions);
+                await testEnvironment.StartServer(serverOptions);
 
                 var options = new MqttClientOptionsBuilder().WithClientId("1");
 
@@ -111,7 +111,7 @@ namespace MQTTnet.Tests
         {
             try
             {
-                return await testEnvironment.ConnectClientAsync(options);
+                return await testEnvironment.ConnectClient(options);
             }
             catch (System.Exception)
             {

Tests/MQTTnet.Core.Tests/Server/Shared_Subscriptions_Tests.cs

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Shared_Subscriptions_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Server_Reports_Shared_Subscriptions_Not_Supported()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsFalse(connectResult.SharedSubscriptionAvailable);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/Status_Tests.cs

@@ -1,26 +1,26 @@
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Threading.Tasks;
-using MQTTnet.Client.Options;
-using MQTTnet.Tests.Mockups;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
+using MQTTnet.Client.Options;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
+using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public sealed class Server_Status_Tests : BaseTestClass
+    public sealed class Status_Tests : BaseTestClass
     {
         [TestMethod]
         public async Task Show_Client_And_Session_Statistics()
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client1"));
-                var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client2"));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("client1"));
+                var c2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("client2"));
 
                 await Task.Delay(500);
 
@@ -51,9 +51,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync();
+                var server = await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client1"));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("client1"));
                 
                 await Task.Delay(1000);
 
@@ -79,10 +79,10 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithPersistentSessions());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithPersistentSessions());
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client1"));
-                var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client2"));
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("client1"));
+                var c2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("client2"));
 
                 await c1.DisconnectAsync();
 
@@ -111,9 +111,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithPersistentSessions());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithPersistentSessions());
 
-                var c1 = await testEnvironment.ConnectClientAsync();
+                var c1 = await testEnvironment.ConnectClient();
 
                 for (var i = 1; i < 25; i++)
                 {
@@ -132,9 +132,9 @@ namespace MQTTnet.Tests
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithPersistentSessions());
+                var server = await testEnvironment.StartServer(new MqttServerOptionsBuilder().WithPersistentSessions());
 
-                var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithNoKeepAlive());
+                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithNoKeepAlive());
 
                 for (var i = 1; i < 25; i++)
                 {

Tests/MQTTnet.Core.Tests/Server/Subscription_Identifier_Tests.cs

@@ -0,0 +1,89 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Subscription_Identifier_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Server_Reports_Subscription_Identifiers_Supported()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+                
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsTrue(connectResult.SubscriptionIdentifiersAvailable);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Subscribe_With_Subscription_Identifier()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+                
+                var client1 = await testEnvironment.ConnectClient();
+                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client1);
+                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic").Build();
+                var subscribeOptions = testEnvironment.Factory.CreateSubscribeOptionsBuilder().WithSubscriptionIdentifier(456).WithTopicFilter(topicFilter).Build();
+                
+                await client1.SubscribeAsync(subscribeOptions);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(0);
+                
+                // The client will publish a message where it is itself subscribing to.
+                await client1.PublishAsync("Topic", "Payload", true);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(1);
+
+                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(456);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Subscribe_With_Multiple_Subscription_Identifiers()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+                
+                var client1 = await testEnvironment.ConnectClient();
+                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client1);
+                
+                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic/A").Build();
+                var subscribeOptions = testEnvironment.Factory.CreateSubscribeOptionsBuilder().WithSubscriptionIdentifier(456).WithTopicFilter(topicFilter).Build();
+                await client1.SubscribeAsync(subscribeOptions);
+                
+                await LongTestDelay();
+                
+                topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic/+").Build();
+                subscribeOptions = testEnvironment.Factory.CreateSubscribeOptionsBuilder().WithSubscriptionIdentifier(789).WithTopicFilter(topicFilter).Build();
+                await client1.SubscribeAsync(subscribeOptions);
+                
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(0);
+                
+                // The client will publish a message where it is itself subscribing to.
+                await client1.PublishAsync("Topic/A", "Payload", true);
+                await LongTestDelay();
+
+                applicationMessageHandler.AssertReceivedCountEquals(1);
+
+                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(456);
+                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(789);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Server/TopicFilterComparer_Tests.cs

@@ -1,8 +1,7 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Server;
 using MQTTnet.Server.Internal;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
     public class TopicFilterComparer_Tests

Tests/MQTTnet.Core.Tests/Server/Topic_Alias_Tests.cs

@@ -3,24 +3,42 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
+using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
-using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
-    public class Server_TopicAlias_Tests
+    public sealed class Topic_Alias_Tests : BaseTestClass
     {
         [TestMethod]
-        public async Task Publish_After_Client_Connects()
+        public async Task Server_Reports_Topic_Alias_Supported()
         {
-            using (var testEnvironment = new TestEnvironment())
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
+                
+                var client = testEnvironment.CreateClient();
+                
+                var connectResult = await client.ConnectAsync(new MqttClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                    .Build());
+                
+                Assert.AreEqual(connectResult.TopicAliasMaximum, ushort.MaxValue);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Publish_With_Topic_Alias()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
 
                 var receivedTopics = new List<string>();
 
-                var c1 = await testEnvironment.ConnectClientAsync(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
+                var c1 = await testEnvironment.ConnectClient(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
                 c1.UseApplicationMessageReceivedHandler(e =>
                 {
                     lock (receivedTopics)
@@ -31,7 +49,7 @@ namespace MQTTnet.Tests
 
                 await c1.SubscribeAsync("#");
 
-                var c2 = await testEnvironment.ConnectClientAsync(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
+                var c2 = await testEnvironment.ConnectClient(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var message = new MqttApplicationMessage
                 {

Tests/MQTTnet.Core.Tests/Server/User_Properties_Tests.cs

@@ -8,7 +8,7 @@ using MQTTnet.Client.Subscribing;
 using MQTTnet.Formatter;
 using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests.MQTTv5
+namespace MQTTnet.Tests.Server
 {
     [TestClass]
     public class Feature_Tests
@@ -20,10 +20,10 @@ namespace MQTTnet.Tests.MQTTv5
         {
             using (var testEnvironment = new TestEnvironment(TestContext))
             {
-                await testEnvironment.StartServerAsync();
+                await testEnvironment.StartServer();
 
-                var sender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
-                var receiver = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+                var sender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+                var receiver = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
 
                 var message = new MqttApplicationMessageBuilder()
                     .WithTopic("A")

Tests/MQTTnet.Core.Tests/Server/Wildcard_Subscription_Available_Tests.cs

@@ -0,0 +1,43 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Wildcard_Subscription_Available_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Server_Reports_Wildcard_Subscription_Available_Tests_Supported_V3()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V311)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsTrue(connectResult.WildcardSubscriptionAvailable);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Server_Reports_Wildcard_Subscription_Available_Tests_Supported_V5()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var client = testEnvironment.CreateClient();
+                var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
+                    .WithProtocolVersion(MqttProtocolVersion.V500)
+                    .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
+
+                Assert.IsTrue(connectResult.WildcardSubscriptionAvailable);
+            }
+        }
+    }
+}