Nov 7, 2024 · Nov 12, 2024 · Nov 13, 2024 · Nov 13, 2024 · Nov 13, 2024 · Nov 13, 2024
diff --git a/Source/MQTTnet.Tests/MQTTv5/Server_Tests.cs b/Source/MQTTnet.Tests/MQTTv5/Server_Tests.cs
        }

        [TestMethod]
        public async Task Disconnect_with_Reason()
        public async Task Disconnect_with_Reason_MQTTnet()
        {
            using var testEnvironments = CreateMQTTnetTestEnvironment();
            await Disconnect_with_Reason(testEnvironments);
        }

        [TestMethod]
        public async Task Disconnect_with_Reason_AspNetCore()
        {
            using var testEnvironments = CreateAspNetCoreTestEnvironment();
            await Disconnect_with_Reason(testEnvironments);
        }

        private async Task Disconnect_with_Reason(TestEnvironmentCollection testEnvironments)
        {
            using var testEnvironments = CreateMixedTestEnvironment();
            foreach (var testEnvironment in testEnvironments)
            {
                var disconnectReasonTaskSource = new TaskCompletionSource<MqttClientDisconnectReason>();

                // Test client should be connected now

                var testClientId = await testClientIdTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var testClientId = await testClientIdTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));
                Assert.IsTrue(testClientId != null);

                // Have the server disconnect the client with AdministrativeAction reason

                await testEnvironment.Server.DisconnectClientAsync(testClientId, MqttDisconnectReasonCode.AdministrativeAction);

                var disconnectReason = await disconnectReasonTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var disconnectReason = await disconnectReasonTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));
                // The reason should be returned to the client in the DISCONNECT packet

                Assert.AreEqual(MqttClientDisconnectReason.AdministrativeAction, disconnectReason);
diff --git a/Source/MQTTnet.Tests/Mockups/AspNetCoreTestEnvironment.cs b/Source/MQTTnet.Tests/Mockups/AspNetCoreTestEnvironment.cs
 using MQTTnet.AspNetCore;
 using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.LowLevelClient;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using System;
 using System.Linq;
        {
        }

 public override IMqttClientCreateClient()
 protected override IMqttClientCreateClientCore()
        {
            var services = new ServiceCollection();
            var clientBuilder = services.AddMqttClient();
            UseLogger(clientBuilder);

            var s = services.BuildServiceProvider();
            var client = s.GetRequiredService<IMqttClientFactory>().CreateMqttClient();

            client.ConnectingAsync += e =>
            {
                if (TestContext != null)
                {
                    var clientOptions = e.ClientOptions;
                    var existingClientId = clientOptions.ClientId;
                    if (existingClientId != null && !existingClientId.StartsWith(TestContext.TestName))
                    {
                        clientOptions.ClientId = TestContext.TestName + "_" + existingClientId;
                    }
                }

                return CompletedTask.Instance;
            };
            return CreateClientFactory().CreateMqttClient();
        }

    lock (_clients)
 {
    _clients.Add(client);
 }
 protected override ILowLevelMqttClient CreateLowLevelClientCore()
        {
 return CreateClientFactory().CreateLowLevelMqttClient();
        }

            return client;
        private IMqttClientFactory CreateClientFactory()
        {
            var services = new ServiceCollection();
            var clientBuilder = services.AddMqttClient();
            UseMqttLogger(clientBuilder, "[CLIENT]=>");
            return services.BuildServiceProvider().GetRequiredService<IMqttClientFactory>();
        }

        public override MqttServer CreateServer(MqttServerOptions options)
        {
            throw new NotSupportedException("Can not create MqttServer in AspNetCoreTestEnvironment.");
        }

        public overrideasyncTask<MqttServer> StartServer(Action<MqttServerOptionsBuilder> configure)
        public override Task<MqttServer> StartServer(Action<MqttServerOptionsBuilder> configure)
        {
            if (Server != null)
            {
                throw new InvalidOperationException("Server already started.");
            }

            var appBuilder = WebApplication.CreateBuilder();

            var serverBuilder = appBuilder.Services.AddMqttServer(optionsBuilder =>
            {
                optionsBuilder.WithDefaultEndpoint();
                optionsBuilder.WithDefaultEndpointPort(ServerPort);
                optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);
            }).ConfigureMqttServer(configure, o =>
            {
                if (o.DefaultEndpointOptions.Port == 0)
                {
                    var serverPort = GetServerPort();
                    o.DefaultEndpointOptions.Port = serverPort;
                    ServerPort = serverPort;
                }
            });

            UseLogger(serverBuilder);

            appBuilder.WebHost.UseKestrel(k => k.ListenMqtt());
            appBuilder.Host.ConfigureHostOptions(h => h.ShutdownTimeout = TimeSpan.FromMilliseconds(500d));

            _app = appBuilder.Build();
            await _app.StartAsync();
            var optionsBuilder = new MqttServerOptionsBuilder();
            configure?.Invoke(optionsBuilder);
            return StartServer(optionsBuilder);
        }

            Server = _app.Services.GetRequiredService<MqttServer>();
            return Server;
        public override Task<MqttServer> StartServer(MqttServerOptionsBuilder optionsBuilder)
        {
            optionsBuilder.WithDefaultEndpoint();
            optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);
            var serverOptions = optionsBuilder.Build();
            return StartServer(serverOptions);
        }

 public overrideasync Task<MqttServer> StartServer(MqttServerOptionsBuilder optionsBuilder)
 privateasync Task<MqttServer> StartServer(MqttServerOptions serverOptions)
        {
            if (Server != null)
            {
                throw new InvalidOperationException("Server already started.");
            }

            if (ServerPort == 0)
            if (serverOptions.DefaultEndpointOptions.Port == 0)
            {
                ServerPort = GetServerPort();
                var serverPort = ServerPort > 0 ? ServerPort : GetServerPort();
                serverOptions.DefaultEndpointOptions.Port = serverPort;
            }

            optionsBuilder.WithDefaultEndpoint();
            optionsBuilder.WithDefaultEndpointPort(ServerPort);
            optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);

            var appBuilder = WebApplication.CreateBuilder();
            appBuilder.Services.AddSingleton(optionsBuilder.Build());
            var serverBuilder = appBuilder.Services.AddMqttServer();
            appBuilder.Services.AddSingleton(serverOptions);

            UseLogger(serverBuilder);
            var serverBuilder = appBuilder.Services.AddMqttServer();
            UseMqttLogger(serverBuilder, "[SERVER]=>");

            appBuilder.WebHost.UseKestrel(k => k.ListenMqtt());
            appBuilder.Host.ConfigureHostOptions(h => h.ShutdownTimeout = TimeSpan.FromMilliseconds(500d));
            await _app.StartAsync();

            Server = _app.Services.GetRequiredService<MqttServer>();
            return Server;
        }
            ServerPort = serverOptions.DefaultEndpointOptions.Port;

        public override void Dispose()
        {
            if (_app != null)
            Server.ValidatingConnectionAsync += e =>
            {
                _app.StopAsync().ConfigureAwait(false).GetAwaiter().GetResult();
                _app.DisposeAsync().ConfigureAwait(false).GetAwaiter().GetResult();
                _app = null;
            }
            base.Dispose();
                if (TestContext != null)
                {
                    // Null is used when the client id is assigned from the server!
                    if (!string.IsNullOrEmpty(e.ClientId) && !e.ClientId.StartsWith(TestContext.TestName))
                    {
                        TrackException(new InvalidOperationException($"Invalid client ID used ({e.ClientId}). It must start with UnitTest name."));
                        e.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
                    }
                }

                return CompletedTask.Instance;
            };

            return Server;
        }


        private static int GetServerPort()
        {
            var listeners = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners();
            return port;
        }

        private voidUseLogger(IMqttBuilder builder)
        private voidUseMqttLogger(IMqttBuilder builder, string categoryNamePrefix)
        {
            if (EnableLogger)
            {
                builder.UseAspNetCoreMqttNetLogger();
                builder.UseAspNetCoreMqttNetLogger(l => l.CategoryNamePrefix = categoryNamePrefix);
            }
            else
            {
                builder.UseMqttNetNullLogger();
            }
        }

        public override void Dispose()
        {
            base.Dispose();
            if (_app != null)
            {
                _app.StopAsync().ConfigureAwait(false).GetAwaiter().GetResult();
                _app.DisposeAsync().ConfigureAwait(false).GetAwaiter().GetResult();
                _app = null;
            }
        }
    }
 }
diff --git a/Source/MQTTnet.Tests/Mockups/TestEnvironment.cs b/Source/MQTTnet.Tests/Mockups/TestEnvironment.cs
    {
        bool _disposed = false;
        readonly List<string> _clientErrors = new();
 protectedreadonly List<IMqttClient> _clients = new();
        readonly List<IMqttClient> _clients = new();
        readonly List<Exception> _exceptions = new();
        readonly List<ILowLevelMqttClient> _lowLevelClients = new();
        readonly MqttProtocolVersion _protocolVersion;
            return new TestApplicationMessageReceivedHandler(mqttClient);
        }

        publicvirtualIMqttClient CreateClient()
        public IMqttClient CreateClient()
        {
            var logger = EnableLogger ? (IMqttNetLogger)ClientLogger : MqttNetNullLogger.Instance;

            var client = ClientFactory.CreateMqttClient(logger);
            var client = CreateClientCore();

            client.ConnectingAsync += e =>
            {
            return client;
        }

        protected virtual IMqttClient CreateClientCore()
        {
            var logger = EnableLogger ? (IMqttNetLogger)ClientLogger : MqttNetNullLogger.Instance;
            return ClientFactory.CreateMqttClient(logger);
        }

        public MqttClientOptions CreateDefaultClientOptions()
        {
            return CreateDefaultClientOptionsBuilder().Build();

        public ILowLevelMqttClient CreateLowLevelClient()
        {
            var client =ClientFactory.CreateLowLevelMqttClient(ClientLogger);
            var client =CreateLowLevelClientCore();

            lock (_lowLevelClients)
            {
            return client;
        }

        protected virtual ILowLevelMqttClient CreateLowLevelClientCore()
        {
            return ClientFactory.CreateLowLevelMqttClient(ClientLogger);
        }


        public virtual MqttServer CreateServer(MqttServerOptions options)
        {
            if (Server != null)
diff --git a/Source/MQTTnet.Tests/Server/Events_Tests.cs b/Source/MQTTnet.Tests/Server/Events_Tests.cs

                await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);

                var client = await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));
                await client.DisconnectAsync();

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);

                var client = await testEnvironment.ConnectClient();
                await client.SubscribeAsync("The/Topic", MqttQualityOfServiceLevel.AtLeastOnce);

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);

                var client = await testEnvironment.ConnectClient();
                await client.UnsubscribeAsync("The/Topic");

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);

                var client = await testEnvironment.ConnectClient();
                await client.PublishStringAsync("The_Topic", "The_Payload");

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);


                await server.StartAsync();

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);
            }

                await server.StopAsync();

                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
                var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

                Assert.IsNotNull(eventArgs);
            }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -182,9 +182,21 @@ public async Task Reconnect_with_different_SessionExpiryInterval()
		}

		[TestMethod]
		public async Task Disconnect_with_Reason()
		public async Task Disconnect_with_Reason_MQTTnet()
		{
		using var testEnvironments = CreateMQTTnetTestEnvironment();
		await Disconnect_with_Reason(testEnvironments);
		}

		[TestMethod]
		public async Task Disconnect_with_Reason_AspNetCore()
		{
		using var testEnvironments = CreateAspNetCoreTestEnvironment();
		await Disconnect_with_Reason(testEnvironments);
		}

		private async Task Disconnect_with_Reason(TestEnvironmentCollection testEnvironments)
		{
		using var testEnvironments = CreateMixedTestEnvironment();
		foreach (var testEnvironment in testEnvironments)
		{
		var disconnectReasonTaskSource = new TaskCompletionSource<MqttClientDisconnectReason>();
Expand All		@@ -211,14 +223,14 @@ public async Task Disconnect_with_Reason()

		// Test client should be connected now

		var testClientId = await testClientIdTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var testClientId = await testClientIdTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));
		Assert.IsTrue(testClientId != null);

		// Have the server disconnect the client with AdministrativeAction reason

		await testEnvironment.Server.DisconnectClientAsync(testClientId, MqttDisconnectReasonCode.AdministrativeAction);

		var disconnectReason = await disconnectReasonTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var disconnectReason = await disconnectReasonTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));
		// The reason should be returned to the client in the DISCONNECT packet

		Assert.AreEqual(MqttClientDisconnectReason.AdministrativeAction, disconnectReason);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -10,6 +10,8 @@
		using MQTTnet.AspNetCore;
		using MQTTnet.Formatter;
		using MQTTnet.Internal;
		using MQTTnet.LowLevelClient;
		using MQTTnet.Protocol;
		using MQTTnet.Server;
		using System;
		using System.Linq;
Expand All		@@ -32,100 +34,62 @@ public AspNetCoreTestEnvironment(TestContext testContext, MqttProtocolVersion pr
		{
		}

		public override IMqttClientCreateClient()
		protected override IMqttClientCreateClientCore()
		{
		var services = new ServiceCollection();
		var clientBuilder = services.AddMqttClient();
		UseLogger(clientBuilder);

		var s = services.BuildServiceProvider();
		var client = s.GetRequiredService<IMqttClientFactory>().CreateMqttClient();

		client.ConnectingAsync += e =>
		{
		if (TestContext != null)
		{
		var clientOptions = e.ClientOptions;
		var existingClientId = clientOptions.ClientId;
		if (existingClientId != null && !existingClientId.StartsWith(TestContext.TestName))
		{
		clientOptions.ClientId = TestContext.TestName + "_" + existingClientId;
		}
		}

		return CompletedTask.Instance;
		};
		return CreateClientFactory().CreateMqttClient();
		}

		lock (_clients)
		{
		_clients.Add(client);
		}
		protected override ILowLevelMqttClient CreateLowLevelClientCore()
		{
		return CreateClientFactory().CreateLowLevelMqttClient();
		}

		return client;
		private IMqttClientFactory CreateClientFactory()
		{
		var services = new ServiceCollection();
		var clientBuilder = services.AddMqttClient();
		UseMqttLogger(clientBuilder, "[CLIENT]=>");
		return services.BuildServiceProvider().GetRequiredService<IMqttClientFactory>();
		}

		public override MqttServer CreateServer(MqttServerOptions options)
		{
		throw new NotSupportedException("Can not create MqttServer in AspNetCoreTestEnvironment.");
		}

		public overrideasyncTask<MqttServer> StartServer(Action<MqttServerOptionsBuilder> configure)
		public override Task<MqttServer> StartServer(Action<MqttServerOptionsBuilder> configure)
		{
		if (Server != null)
		{
		throw new InvalidOperationException("Server already started.");
		}

		var appBuilder = WebApplication.CreateBuilder();

		var serverBuilder = appBuilder.Services.AddMqttServer(optionsBuilder =>
		{
		optionsBuilder.WithDefaultEndpoint();
		optionsBuilder.WithDefaultEndpointPort(ServerPort);
		optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);
		}).ConfigureMqttServer(configure, o =>
		{
		if (o.DefaultEndpointOptions.Port == 0)
		{
		var serverPort = GetServerPort();
		o.DefaultEndpointOptions.Port = serverPort;
		ServerPort = serverPort;
		}
		});

		UseLogger(serverBuilder);

		appBuilder.WebHost.UseKestrel(k => k.ListenMqtt());
		appBuilder.Host.ConfigureHostOptions(h => h.ShutdownTimeout = TimeSpan.FromMilliseconds(500d));

		_app = appBuilder.Build();
		await _app.StartAsync();
		var optionsBuilder = new MqttServerOptionsBuilder();
		configure?.Invoke(optionsBuilder);
		return StartServer(optionsBuilder);
		}

		Server = _app.Services.GetRequiredService<MqttServer>();
		return Server;
		public override Task<MqttServer> StartServer(MqttServerOptionsBuilder optionsBuilder)
		{
		optionsBuilder.WithDefaultEndpoint();
		optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);
		var serverOptions = optionsBuilder.Build();
		return StartServer(serverOptions);
		}

		public overrideasync Task<MqttServer> StartServer(MqttServerOptionsBuilder optionsBuilder)
		privateasync Task<MqttServer> StartServer(MqttServerOptions serverOptions)
		{
		if (Server != null)
		{
		throw new InvalidOperationException("Server already started.");
		}

		if (ServerPort == 0)
		if (serverOptions.DefaultEndpointOptions.Port == 0)
		{
		ServerPort = GetServerPort();
		var serverPort = ServerPort > 0 ? ServerPort : GetServerPort();
		serverOptions.DefaultEndpointOptions.Port = serverPort;
		}

		optionsBuilder.WithDefaultEndpoint();
		optionsBuilder.WithDefaultEndpointPort(ServerPort);
		optionsBuilder.WithMaxPendingMessagesPerClient(int.MaxValue);

		var appBuilder = WebApplication.CreateBuilder();
		appBuilder.Services.AddSingleton(optionsBuilder.Build());
		var serverBuilder = appBuilder.Services.AddMqttServer();
		appBuilder.Services.AddSingleton(serverOptions);

		UseLogger(serverBuilder);
		var serverBuilder = appBuilder.Services.AddMqttServer();
		UseMqttLogger(serverBuilder, "[SERVER]=>");

		appBuilder.WebHost.UseKestrel(k => k.ListenMqtt());
		appBuilder.Host.ConfigureHostOptions(h => h.ShutdownTimeout = TimeSpan.FromMilliseconds(500d));
Expand All		@@ -134,20 +98,27 @@ public override async Task<MqttServer> StartServer(MqttServerOptionsBuilder opti
		await _app.StartAsync();

		Server = _app.Services.GetRequiredService<MqttServer>();
		return Server;
		}
		ServerPort = serverOptions.DefaultEndpointOptions.Port;

		public override void Dispose()
		{
		if (_app != null)
		Server.ValidatingConnectionAsync += e =>
		{
		_app.StopAsync().ConfigureAwait(false).GetAwaiter().GetResult();
		_app.DisposeAsync().ConfigureAwait(false).GetAwaiter().GetResult();
		_app = null;
		}
		base.Dispose();
		if (TestContext != null)
		{
		// Null is used when the client id is assigned from the server!
		if (!string.IsNullOrEmpty(e.ClientId) && !e.ClientId.StartsWith(TestContext.TestName))
		{
		TrackException(new InvalidOperationException($"Invalid client ID used ({e.ClientId}). It must start with UnitTest name."));
		e.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
		}
		}

		return CompletedTask.Instance;
		};

		return Server;
		}


		private static int GetServerPort()
		{
		var listeners = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners();
Expand All		@@ -161,16 +132,27 @@ private static int GetServerPort()
		return port;
		}

		private voidUseLogger(IMqttBuilder builder)
		private voidUseMqttLogger(IMqttBuilder builder, string categoryNamePrefix)
		{
		if (EnableLogger)
		{
		builder.UseAspNetCoreMqttNetLogger();
		builder.UseAspNetCoreMqttNetLogger(l => l.CategoryNamePrefix = categoryNamePrefix);
		}
		else
		{
		builder.UseMqttNetNullLogger();
		}
		}

		public override void Dispose()
		{
		base.Dispose();
		if (_app != null)
		{
		_app.StopAsync().ConfigureAwait(false).GetAwaiter().GetResult();
		_app.DisposeAsync().ConfigureAwait(false).GetAwaiter().GetResult();
		_app = null;
		}
		}
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -23,7 +23,7 @@ public class TestEnvironment : IDisposable
		{
		bool _disposed = false;
		readonly List<string> _clientErrors = new();
		protectedreadonly List<IMqttClient> _clients = new();
		readonly List<IMqttClient> _clients = new();
		readonly List<Exception> _exceptions = new();
		readonly List<ILowLevelMqttClient> _lowLevelClients = new();
		readonly MqttProtocolVersion _protocolVersion;
Expand DownExpand Up		@@ -196,11 +196,9 @@ public TestApplicationMessageReceivedHandler CreateApplicationMessageHandler(IMq
		return new TestApplicationMessageReceivedHandler(mqttClient);
		}

		publicvirtualIMqttClient CreateClient()
		public IMqttClient CreateClient()
		{
		var logger = EnableLogger ? (IMqttNetLogger)ClientLogger : MqttNetNullLogger.Instance;

		var client = ClientFactory.CreateMqttClient(logger);
		var client = CreateClientCore();

		client.ConnectingAsync += e =>
		{
Expand All		@@ -225,6 +223,12 @@ public virtual IMqttClient CreateClient()
		return client;
		}

		protected virtual IMqttClient CreateClientCore()
		{
		var logger = EnableLogger ? (IMqttNetLogger)ClientLogger : MqttNetNullLogger.Instance;
		return ClientFactory.CreateMqttClient(logger);
		}

		public MqttClientOptions CreateDefaultClientOptions()
		{
		return CreateDefaultClientOptionsBuilder().Build();
Expand All		@@ -240,7 +244,7 @@ public MqttClientOptionsBuilder CreateDefaultClientOptionsBuilder()

		public ILowLevelMqttClient CreateLowLevelClient()
		{
		var client =ClientFactory.CreateLowLevelMqttClient(ClientLogger);
		var client =CreateLowLevelClientCore();

		lock (_lowLevelClients)
		{
Expand All		@@ -250,6 +254,12 @@ public ILowLevelMqttClient CreateLowLevelClient()
		return client;
		}

		protected virtual ILowLevelMqttClient CreateLowLevelClientCore()
		{
		return ClientFactory.CreateLowLevelMqttClient(ClientLogger);
		}


		public virtual MqttServer CreateServer(MqttServerOptions options)
		{
		if (Server != null)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -33,7 +33,7 @@ public async Task Fire_Client_Connected_Event()

		await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);

Expand DownExpand Up		@@ -63,7 +63,7 @@ public async Task Fire_Client_Disconnected_Event()
		var client = await testEnvironment.ConnectClient(o => o.WithCredentials("TheUser"));
		await client.DisconnectAsync();

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);

Expand DownExpand Up		@@ -92,7 +92,7 @@ public async Task Fire_Client_Subscribed_Event()
		var client = await testEnvironment.ConnectClient();
		await client.SubscribeAsync("The/Topic", MqttQualityOfServiceLevel.AtLeastOnce);

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);

Expand DownExpand Up		@@ -121,7 +121,7 @@ public async Task Fire_Client_Unsubscribed_Event()
		var client = await testEnvironment.ConnectClient();
		await client.UnsubscribeAsync("The/Topic");

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);

Expand DownExpand Up		@@ -149,7 +149,7 @@ public async Task Fire_Application_Message_Received_Event()
		var client = await testEnvironment.ConnectClient();
		await client.PublishStringAsync("The_Topic", "The_Payload");

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);

Expand All		@@ -176,7 +176,7 @@ public async Task Fire_Started_Event()

		await server.StartAsync();

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);
		}
Expand All		@@ -199,7 +199,7 @@ public async Task Fire_Stopped_Event()

		await server.StopAsync();

		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d)); ;
		var eventArgs = await eventArgsTaskSource.Task.WaitAsync(TimeSpan.FromSeconds(10d));

		Assert.IsNotNull(eventArgs);
		}
Expand Down