Refactor namespaces.

Tests/MQTTnet.Core.Tests/AsyncAutoResentEventTests.cs

@@ -1,10 +1,10 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Internal;
-using System;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Internal;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     // Inspired from the vs-threading tests (https://github.com/Microsoft/vs-threading/blob/master/src/Microsoft.VisualStudio.Threading.Tests/AsyncAutoResetEventTests.cs)

Tests/MQTTnet.Core.Tests/AsyncLockTests.cs

@@ -3,7 +3,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Internal;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class AsyncLockTests

Tests/MQTTnet.Core.Tests/BlockingQueueTests.cs

@@ -3,7 +3,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Internal;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class BlockingQueueTests

Tests/MQTTnet.Core.Tests/ExtensionTests.cs

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Exceptions;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class ExtensionTests

Tests/MQTTnet.Core.Tests/MQTTnet.Tests.csproj

@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MSTest.TestAdapter" Version="1.3.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
+    <PackageReference Include="MSTest.TestAdapter" Version="1.4.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="1.4.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
   </ItemGroup>
 

Tests/MQTTnet.Core.Tests/MQTTv5/MqttClientTests.cs

@@ -0,0 +1,245 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Client.Options;
+using MQTTnet.Client.Publishing;
+using MQTTnet.Client.Subscribing;
+using MQTTnet.Client.Unsubscribing;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
+
+namespace MQTTnet.Tests.MQTTv5
+{
+    [TestClass]
+    public class Client_Tests
+    {
+        [TestMethod]
+        public async Task Client_Connect()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Connect_And_Disconnect()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                await client.DisconnectAsync();
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Subscribe()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                var result = await client.SubscribeAsync("a", MqttQualityOfServiceLevel.AtLeastOnce);
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(1, result.Items.Count);
+                Assert.AreEqual(MqttClientSubscribeResultCode.GrantedQoS1, result.Items[0].ResultCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Unsubscribe()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                await client.SubscribeAsync("a");
+                var result = await client.UnsubscribeAsync("a");
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(1, result.Items.Count);
+                Assert.AreEqual(MqttClientUnsubscribeResultCode.Success, result.Items[0].ReasonCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Publish_QoS0()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                var result = await client.PublishAsync("a", "b");
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Publish_QoS1()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.AtLeastOnce);
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Publish_QoS2()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.ExactlyOnce);
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Client_Publish_With_Properties()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                var applicationMessage = new MqttApplicationMessageBuilder()
+                    .WithTopic("Hello")
+                    .WithPayload("World")
+                    .WithAtMostOnceQoS()
+                    .WithUserProperty("x", "1")
+                    .WithUserProperty("y", "2")
+                    .WithResponseTopic("response")
+                    .WithContentType("text")
+                    .WithMessageExpiryInterval(50)
+                    .WithCorrelationData(new byte[12])
+                    .WithTopicAlias(2)
+                    .Build();
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                var result = await client.PublishAsync(applicationMessage);
+                await client.DisconnectAsync();
+
+                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Subscribe_And_Publish()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            var client1 = new MqttFactory().CreateMqttClient();
+            var client2 = new MqttFactory().CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                var receivedMessages = new List<MqttApplicationMessageReceivedEventArgs>();
+
+                await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                client1.ApplicationMessageReceived += (s, e) =>
+                {
+                    lock (receivedMessages)
+                    {
+                        receivedMessages.Add(e);
+                    }
+                };
+
+                await client1.SubscribeAsync("a");
+
+                await client2.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client2").WithProtocolVersion(MqttProtocolVersion.V500).Build());
+                await client2.PublishAsync("a", "b");
+
+                await Task.Delay(500);
+
+                await client2.DisconnectAsync();
+                await client1.DisconnectAsync();
+
+                Assert.AreEqual(1, receivedMessages.Count);
+                Assert.AreEqual("client1", receivedMessages[0].ClientId);
+                Assert.AreEqual("a", receivedMessages[0].ApplicationMessage.Topic);
+                Assert.AreEqual("b", receivedMessages[0].ApplicationMessage.ConvertPayloadToString());
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/ManagedMqttClientTests.cs

@@ -1,9 +1,9 @@
-using MQTTnet.Extensions.ManagedClient;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class ManagedMqttClientTests

Tests/MQTTnet.Core.Tests/MqttApplicationMessageBuilderTests.cs

@@ -4,7 +4,7 @@ using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Protocol;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttApplicationMessageBuilderTests

Tests/MQTTnet.Core.Tests/MqttClientTests.cs

@@ -2,17 +2,14 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Sockets;
-using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Adapter;
 using MQTTnet.Client;
-using MQTTnet.Diagnostics;
+using MQTTnet.Client.Options;
 using MQTTnet.Exceptions;
-using MQTTnet.Packets;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttClientTests
@@ -128,39 +125,39 @@ namespace MQTTnet.Core.Tests
             }
         }
 
-#if DEBUG
-        [TestMethod]
-        public async Task Client_Cleanup_On_Authentification_Fails()
-        {
-            var channel = new TestMqttCommunicationAdapter();
-            var channel2 = new TestMqttCommunicationAdapter();
-            channel.Partner = channel2;
-            channel2.Partner = channel;
+//#if DEBUG
+//        [TestMethod]
+//        public async Task Client_Cleanup_On_Authentification_Fails()
+//        {
+//            var channel = new TestMqttCommunicationAdapter();
+//            var channel2 = new TestMqttCommunicationAdapter();
+//            channel.Partner = channel2;
+//            channel2.Partner = channel;
 
-            Task.Run(async () => {
-                var connect = await channel2.ReceivePacketAsync(TimeSpan.Zero, CancellationToken.None);
-                await channel2.SendPacketAsync(new MqttConnAckPacket
-                {
-                    ConnectReturnCode = Protocol.MqttConnectReturnCode.ConnectionRefusedNotAuthorized
-                }, CancellationToken.None);
-            });
+//            Task.Run(async () => {
+//                var connect = await channel2.ReceivePacketAsync(TimeSpan.Zero, CancellationToken.None);
+//                await channel2.SendPacketAsync(new MqttConnAckPacket
+//                {
+//                    ConnectReturnCode = Protocol.MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+//                }, CancellationToken.None);
+//            });
             
-            var fake = new TestMqttCommunicationAdapterFactory(channel);
+//            var fake = new TestMqttCommunicationAdapterFactory(channel);
 
-            var client = new MqttClient(fake, new MqttNetLogger());
+//            var client = new MqttClient(fake, new MqttNetLogger());
 
-            try
-            {
-                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("any-server").Build());
-            }
-            catch (Exception ex)
-            {
-                Assert.IsInstanceOfType(ex, typeof(MqttConnectingFailedException));
-            }
+//            try
+//            {
+//                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("any-server").Build());
+//            }
+//            catch (Exception ex)
+//            {
+//                Assert.IsInstanceOfType(ex, typeof(MqttConnectingFailedException));
+//            }
 
-            Assert.IsTrue(client._packetReceiverTask == null || client._packetReceiverTask.IsCompleted, "receive loop not completed");
-            Assert.IsTrue(client._keepAliveMessageSenderTask == null || client._keepAliveMessageSenderTask.IsCompleted, "keepalive loop not completed");
-        }
-#endif
+//            Assert.IsTrue(client._packetReceiverTask == null || client._packetReceiverTask.IsCompleted, "receive loop not completed");
+//            Assert.IsTrue(client._keepAliveMessageSenderTask == null || client._keepAliveMessageSenderTask.IsCompleted, "keepalive loop not completed");
+//        }
+//#endif
     }
 }

Tests/MQTTnet.Core.Tests/MqttKeepAliveMonitorTests.cs

@@ -8,7 +8,7 @@ using MQTTnet.Diagnostics;
 using MQTTnet.Packets;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttKeepAliveMonitorTests

Tests/MQTTnet.Core.Tests/MqttPacketIdentifierProviderTests.cs

@@ -1,7 +1,7 @@
-using Microsoft.VisualStudio.TestTools .UnitTesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttPacketIdentifierProviderTests

Tests/MQTTnet.Core.Tests/MqttPacketReaderTests.cs

@@ -5,7 +5,7 @@ using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Internal;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttPacketReaderTests

Tests/MQTTnet.Core.Tests/MqttPacketSerializerTests.cs

@@ -6,13 +6,12 @@ using System.Threading;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Formatter;
-using MQTTnet.Formatter.V310;
-using MQTTnet.Formatter.V311;
+using MQTTnet.Formatter.V3;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttPacketSerializerTests
@@ -112,7 +111,7 @@ namespace MQTTnet.Core.Tests
             var p = new MqttConnAckPacket
             {
                 IsSessionPresent = true,
-                ConnectReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+                ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
             };
 
             SerializeAndCompare(p, "IAIBBQ==");
@@ -123,7 +122,7 @@ namespace MQTTnet.Core.Tests
         {
             var p = new MqttConnAckPacket
             {
-                ConnectReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+                ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
             };
 
             SerializeAndCompare(p, "IAIABQ==", MqttProtocolVersion.V310);
@@ -135,7 +134,7 @@ namespace MQTTnet.Core.Tests
             var p = new MqttConnAckPacket
             {
                 IsSessionPresent = true,
-                ConnectReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+                ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
             };
 
             DeserializeAndCompare(p, "IAIBBQ==");
@@ -146,7 +145,7 @@ namespace MQTTnet.Core.Tests
         {
             var p = new MqttConnAckPacket
             {
-                ConnectReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+                ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized
             };
 
             DeserializeAndCompare(p, "IAIABQ==", MqttProtocolVersion.V310);
@@ -189,7 +188,8 @@ namespace MQTTnet.Core.Tests
 
             var receivedPacket = new ReceivedMqttPacket(
                 header.Flags,
-                new MqttPacketBodyReader(buffer.Array, (uint)eof - header.RemainingLength, (uint)(buffer.Count + buffer.Offset)));
+                new MqttPacketBodyReader(buffer.Array, eof - header.RemainingLength, buffer.Count + buffer.Offset),
+                0);
 
             var packet = (MqttPublishPacket)serializer.Decode(receivedPacket);
 
@@ -401,9 +401,9 @@ namespace MQTTnet.Core.Tests
                 PacketIdentifier = 123
             };
 
-            p.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce));
-            p.TopicFilters.Add(new TopicFilter("1/2/3", MqttQualityOfServiceLevel.AtLeastOnce));
-            p.TopicFilters.Add(new TopicFilter("x/y/z", MqttQualityOfServiceLevel.AtMostOnce));
+            p.TopicFilters.Add(new TopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce });
+            p.TopicFilters.Add(new TopicFilter { Topic = "1/2/3", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
+            p.TopicFilters.Add(new TopicFilter { Topic = "x/y/z", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
 
             SerializeAndCompare(p, "ghoAewAFQS9CL0MCAAUxLzIvMwEABXgveS96AA==");
         }
@@ -416,9 +416,9 @@ namespace MQTTnet.Core.Tests
                 PacketIdentifier = 123
             };
 
-            p.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.ExactlyOnce));
-            p.TopicFilters.Add(new TopicFilter("1/2/3", MqttQualityOfServiceLevel.AtLeastOnce));
-            p.TopicFilters.Add(new TopicFilter("x/y/z", MqttQualityOfServiceLevel.AtMostOnce));
+            p.TopicFilters.Add(new TopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce });
+            p.TopicFilters.Add(new TopicFilter { Topic = "1/2/3", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
+            p.TopicFilters.Add(new TopicFilter { Topic = "x/y/z", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
 
             DeserializeAndCompare(p, "ghoAewAFQS9CL0MCAAUxLzIvMwEABXgveS96AA==");
         }
@@ -431,10 +431,10 @@ namespace MQTTnet.Core.Tests
                 PacketIdentifier = 123
             };
 
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS0);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS1);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS2);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.Failure);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS0);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS1);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS2);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.Failure);
 
             SerializeAndCompare(p, "kAYAewABAoA=");
         }
@@ -447,10 +447,10 @@ namespace MQTTnet.Core.Tests
                 PacketIdentifier = 123
             };
 
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS0);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS1);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS2);
-            p.SubscribeReturnCodes.Add(MqttSubscribeReturnCode.Failure);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS0);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS1);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.SuccessMaximumQoS2);
+            p.ReturnCodes.Add(MqttSubscribeReturnCode.Failure);
 
             DeserializeAndCompare(p, "kAYAewABAoA=");
         }
@@ -552,9 +552,9 @@ namespace MQTTnet.Core.Tests
                 var fixedHeader = new byte[2];
                 var header = new MqttPacketReader(channel).ReadFixedHeaderAsync(fixedHeader, CancellationToken.None).GetAwaiter().GetResult();
 
-                using (var bodyStream = new MemoryStream(Join(buffer1), (int)headerStream.Position, (int)header.RemainingLength))
+                using (var bodyStream = new MemoryStream(Join(buffer1), (int)headerStream.Position, header.RemainingLength))
                 {
-                    var deserializedPacket = serializer.Decode(new ReceivedMqttPacket(header.Flags, new MqttPacketBodyReader(bodyStream.ToArray(), 0, (int)bodyStream.Length)));
+                    var deserializedPacket = serializer.Decode(new ReceivedMqttPacket(header.Flags, new MqttPacketBodyReader(bodyStream.ToArray(), 0, (int)bodyStream.Length), 0));
                     var buffer2 = serializer.Encode(deserializedPacket);
 
                     Assert.AreEqual(expectedBase64Value, Convert.ToBase64String(Join(buffer2)));
@@ -590,7 +590,7 @@ namespace MQTTnet.Core.Tests
 
                 using (var bodyStream = new MemoryStream(Join(buffer1), (int)headerStream.Position, (int)header.RemainingLength))
                 {
-                    return (T)serializer.Decode(new ReceivedMqttPacket(header.Flags, new MqttPacketBodyReader(bodyStream.ToArray(), 0, (int)bodyStream.Length)));
+                    return (T)serializer.Decode(new ReceivedMqttPacket(header.Flags, new MqttPacketBodyReader(bodyStream.ToArray(), 0, (int)bodyStream.Length), 0));
                 }
             }
         }

Tests/MQTTnet.Core.Tests/MqttPacketWriterTests.cs

@@ -1,7 +1,7 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Formatter;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttPacketWriterTests

Tests/MQTTnet.Core.Tests/MqttServerTests.cs

@@ -1,19 +1,19 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client;
-using MQTTnet.Diagnostics;
-using MQTTnet.Protocol;
-using MQTTnet.Server;
-using System;
-using System.Collections.Concurrent;
+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;
+using MQTTnet.Client.Options;
+using MQTTnet.Diagnostics;
 using MQTTnet.Implementations;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttServerTests
@@ -111,7 +111,7 @@ namespace MQTTnet.Core.Tests
                         subscribeEventCalled = e.TopicFilter.Topic == "a" && e.ClientId == "c1";
                     };
 
-                await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
+                await c1.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
                 await Task.Delay(500);
                 Assert.IsTrue(subscribeEventCalled, "Subscribe event not called.");
 
@@ -158,7 +158,7 @@ namespace MQTTnet.Core.Tests
                 c1.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
-                await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
+                await c1.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
 
                 await s.PublishAsync(message);
                 await Task.Delay(500);
@@ -213,8 +213,8 @@ namespace MQTTnet.Core.Tests
                 };
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
-                await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
-                await c2.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
+                await c1.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
+                await c2.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
 
                 //await Task.WhenAll(Publish(c1, message), Publish(c2, message));
                 await Publish(c1, message);
@@ -228,7 +228,7 @@ namespace MQTTnet.Core.Tests
 
             Assert.AreEqual(2000, receivedMessagesCount);
         }
-        
+
         [TestMethod]
         public async Task MqttServer_SessionTakeover()
         {
@@ -373,7 +373,7 @@ namespace MQTTnet.Core.Tests
             {
                 await server.StopAsync();
             }
-            
+
             Assert.IsTrue(clientWasConnected);
             Assert.AreEqual(0, errors);
         }
@@ -554,7 +554,7 @@ namespace MQTTnet.Core.Tests
                 c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
 
                 await Task.Delay(200);
-                await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
+                await c2.SubscribeAsync(new TopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
                 await Task.Delay(500);
             }
             finally

Tests/MQTTnet.Core.Tests/MqttSubscriptionsManagerTests.cs

@@ -3,7 +3,7 @@ using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class MqttSubscriptionsManagerTests
@@ -29,7 +29,7 @@ namespace MQTTnet.Core.Tests
             var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
-            sp.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.AtMostOnce));
+            sp.TopicFilters.Add(new TopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
 
             sm.Subscribe(sp);
 
@@ -44,8 +44,8 @@ namespace MQTTnet.Core.Tests
             var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
-            sp.TopicFilters.Add(new TopicFilter("#", MqttQualityOfServiceLevel.AtMostOnce));
-            sp.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.AtLeastOnce));
+            sp.TopicFilters.Add(new TopicFilter { Topic = "#", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
+            sp.TopicFilters.Add(new TopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
 
             sm.Subscribe(sp);
 

Tests/MQTTnet.Core.Tests/RoundtripTimeTests.cs

@@ -4,9 +4,10 @@ using System.Diagnostics;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
+using MQTTnet.Client.Options;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     [TestClass]
     public class RoundtripTimeTests

Tests/MQTTnet.Core.Tests/TestMqttCommunicationAdapter.cs

@@ -6,7 +6,7 @@ using MQTTnet.Adapter;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     public class TestMqttCommunicationAdapter : IMqttChannelAdapter
     {

Tests/MQTTnet.Core.Tests/TestMqttCommunicationAdapterFactory.cs

@@ -1,8 +1,9 @@
 using MQTTnet.Adapter;
 using MQTTnet.Client;
+using MQTTnet.Client.Options;
 using MQTTnet.Diagnostics;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     public class TestMqttCommunicationAdapterFactory : IMqttClientAdapterFactory
     {

Tests/MQTTnet.Core.Tests/TestMqttServerAdapter.cs

@@ -3,10 +3,11 @@ using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.Client;
+using MQTTnet.Client.Options;
 using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     public class TestMqttServerAdapter : IMqttServerAdapter
     {

Tests/MQTTnet.Core.Tests/TestServerExtensions.cs

@@ -1,9 +1,8 @@
-using MQTTnet.Client;
+using System.Threading.Tasks;
+using MQTTnet.Client;
 using MQTTnet.Server;
-using System;
-using System.Threading.Tasks;
 
-namespace MQTTnet.Core.Tests
+namespace MQTTnet.Tests
 {
     public static class TestServerExtensions
     {

Tests/MQTTnet.Core.Tests/TopicFilterComparerTests.cs

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