Use latest language features (#2176)

* Make use of language features line AsyncDispose, init etc.

* Fix build errors

* Improve Unit Tests

* Improve Unit Tests

* Improve Unit Tests

* Update samples

* Remove obsolete benchmarks

* Code cleanup

* Improve unit tests

* Improve Unit Tests

* Fix Unit Tests

* Improve Unit Tests

* Improve Unit Tests

* Restore unit tests

* Exclude load tests from unit tests
This commit is contained in:
Christian
2025-08-30 10:52:59 +02:00
committed by GitHub
parent 247988e633
commit e43e7f8e36
330 changed files with 21417 additions and 22919 deletions
+126 -138
View File
@@ -6,166 +6,154 @@ using MQTTnet.Internal;
using MQTTnet.Packets;
using MQTTnet.Protocol;
namespace MQTTnet.Tests.Server
namespace MQTTnet.Tests.Server;
// ReSharper disable InconsistentNaming
#if DEBUG
[TestClass]
#endif
public sealed class Load_Tests : BaseTestClass
{
[TestClass]
public sealed class Load_Tests : BaseTestClass
[TestMethod]
public async Task Handle_100_000_Messages_In_Low_Level_Client()
{
[TestMethod]
public async Task Handle_100_000_Messages_In_Receiving_Client()
using var testEnvironment = CreateTestEnvironment();
var server = await testEnvironment.StartServer();
var receivedMessages = 0;
server.InterceptingPublishAsync += _ =>
{
using (var testEnvironment = CreateTestEnvironment())
{
await testEnvironment.StartServer();
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
var receivedMessages = 0;
using (var receiverClient = await testEnvironment.ConnectClient())
for (var i = 0; i < 100; i++)
{
_ = Task.Factory.StartNew(
async () =>
{
receiverClient.ApplicationMessageReceivedAsync += e =>
try
{
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
using var client = await testEnvironment.ConnectLowLevelClient();
await receiverClient.SubscribeAsync("t/+");
for (var i = 0; i < 100; i++)
{
_ = Task.Run(
async () =>
await client.SendAsync(
new MqttConnectPacket
{
using (var client = await testEnvironment.ConnectClient())
{
var applicationMessageBuilder = new MqttApplicationMessageBuilder();
ClientId = "Handle_100_000_Messages_In_Low_Level_Client_" + Guid.NewGuid()
},
CancellationToken.None);
for (var j = 0; j < 1000; j++)
{
var message = applicationMessageBuilder.WithTopic("t/" + j)
.Build();
var packet = await client.ReceiveAsync(CancellationToken.None);
await client.PublishAsync(message)
.ConfigureAwait(false);
}
var connAckPacket = packet as MqttConnAckPacket;
await client.DisconnectAsync();
}
});
Assert.IsTrue(connAckPacket != null);
Assert.AreEqual(MqttConnectReasonCode.Success, connAckPacket.ReasonCode);
var publishPacket = new MqttPublishPacket();
for (var j = 0; j < 1000; j++)
{
publishPacket.Topic = j.ToString();
await client.SendAsync(publishPacket, CancellationToken.None).ConfigureAwait(false);
}
await client.DisconnectAsync(CancellationToken.None);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
},
TaskCreationOptions.LongRunning);
}
var result = SpinWait.SpinUntil(() => receivedMessages >= 100000, TimeSpan.FromMinutes(5));
Assert.IsTrue(result);
}
[TestMethod]
public async Task Handle_100_000_Messages_In_Receiving_Client()
{
using var testEnvironment = CreateTestEnvironment();
await testEnvironment.StartServer();
var receivedMessages = 0;
using var receiverClient = await testEnvironment.ConnectClient();
receiverClient.ApplicationMessageReceivedAsync += _ =>
{
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
await receiverClient.SubscribeAsync("t/+");
for (var i = 0; i < 100; i++)
{
_ = Task.Factory.StartNew(
async () =>
{
using var client = await testEnvironment.ConnectClient();
var applicationMessageBuilder = testEnvironment.ClientFactory.CreateApplicationMessageBuilder();
for (var j = 0; j < 1000; j++)
{
var message = applicationMessageBuilder.WithTopic("t/" + j).Build();
await client.PublishAsync(message).ConfigureAwait(false);
}
SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(120));
Assert.AreEqual(100000, receivedMessages);
}
}
await client.DisconnectAsync();
},
TaskCreationOptions.LongRunning);
}
[TestMethod]
public async Task Handle_100_000_Messages_In_Low_Level_Client()
var result = SpinWait.SpinUntil(() => receivedMessages >= 100000, TimeSpan.FromMinutes(5));
Assert.IsTrue(result);
}
[TestMethod]
public async Task Handle_100_000_Messages_In_Server()
{
using var testEnvironment = CreateTestEnvironment();
var server = await testEnvironment.StartServer();
var receivedMessages = 0;
server.InterceptingPublishAsync += _ =>
{
using (var testEnvironment = CreateTestEnvironment())
{
var server = await testEnvironment.StartServer();
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
var receivedMessages = 0;
server.InterceptingPublishAsync += e =>
{
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
for (var i = 0; i < 100; i++)
{
_ = Task.Run(
async () =>
{
try
{
using (var client = await testEnvironment.ConnectLowLevelClient())
{
await client.SendAsync(
new MqttConnectPacket
{
ClientId = "Handle_100_000_Messages_In_Low_Level_Client_" + Guid.NewGuid()
}, CancellationToken.None);
var packet = await client.ReceiveAsync(CancellationToken.None);
var connAckPacket = packet as MqttConnAckPacket;
Assert.IsTrue(connAckPacket != null);
Assert.AreEqual(MqttConnectReasonCode.Success, connAckPacket.ReasonCode);
var publishPacket = new MqttPublishPacket();
for (var j = 0; j < 1000; j++)
{
publishPacket.Topic = j.ToString();
await client.SendAsync(publishPacket, CancellationToken.None)
.ConfigureAwait(false);
}
await client.DisconnectAsync(CancellationToken.None);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
});
}
SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(10));
Assert.AreEqual(100000, receivedMessages);
}
}
[TestMethod]
public async Task Handle_100_000_Messages_In_Server()
for (var i = 0; i < 100; i++)
{
using (var testEnvironment = CreateTestEnvironment())
{
var server = await testEnvironment.StartServer();
var receivedMessages = 0;
server.InterceptingPublishAsync += e =>
_ = Task.Factory.StartNew(
async () =>
{
Interlocked.Increment(ref receivedMessages);
return CompletedTask.Instance;
};
using var client = await testEnvironment.ConnectClient();
var applicationMessageBuilder = new MqttApplicationMessageBuilder();
for (var i = 0; i < 100; i++)
{
_ = Task.Run(
async () =>
{
using (var client = await testEnvironment.ConnectClient())
{
var applicationMessageBuilder = new MqttApplicationMessageBuilder();
for (var j = 0; j < 1000; j++)
{
var message = applicationMessageBuilder.WithTopic(j.ToString()).Build();
for (var j = 0; j < 1000; j++)
{
var message = applicationMessageBuilder.WithTopic(j.ToString())
.Build();
await client.PublishAsync(message).ConfigureAwait(false);
}
await client.PublishAsync(message)
.ConfigureAwait(false);
}
await client.DisconnectAsync();
}
});
}
SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(10));
Assert.AreEqual(100000, receivedMessages);
}
await client.DisconnectAsync();
},
TaskCreationOptions.LongRunning);
}
var result = SpinWait.SpinUntil(() => receivedMessages >= 100000, TimeSpan.FromMinutes(5));
Assert.IsTrue(result);
}
}