test: Add AF_XDP test coverage

Magma.sln

@@ -57,6 +57,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Magma.WinTun.TcpHost", "sam
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Magma.AF_XDP", "src\Magma.AF_XDP\Magma.AF_XDP.csproj", "{5922914B-D7E6-4A23-9A26-5589FD72727B}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Magma.AF_XDP.Facts", "test\Magma.AF_XDP.Facts\Magma.AF_XDP.Facts.csproj", "{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -307,6 +309,18 @@ Global
 		{5922914B-D7E6-4A23-9A26-5589FD72727B}.Release|x64.Build.0 = Release|Any CPU
 		{5922914B-D7E6-4A23-9A26-5589FD72727B}.Release|x86.ActiveCfg = Release|Any CPU
 		{5922914B-D7E6-4A23-9A26-5589FD72727B}.Release|x86.Build.0 = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|x64.Build.0 = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Debug|x86.Build.0 = Debug|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|x64.ActiveCfg = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|x64.Build.0 = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|x86.ActiveCfg = Release|Any CPU
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -332,6 +346,7 @@ Global
 		{503140F9-24F6-41B5-89F2-BB0FB24CCB2E} = {34A1DC50-486C-4BB9-9929-1805CA0B0DD0}
 		{845A5A0B-E59B-46AF-BF95-4FC50D660967} = {23E375E0-8A4A-4D6A-8C96-9F2046CE9EB0}
 		{5922914B-D7E6-4A23-9A26-5589FD72727B} = {34A1DC50-486C-4BB9-9929-1805CA0B0DD0}
+		{8EDE1D3D-0D43-4CE5-B136-30231A93D60D} = {B1BA53C8-CCCF-46D5-BA9F-6031811F2E19}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {99D656D2-FC86-462A-BB4C-610D644ADC62}

test/Magma.AF_XDP.Facts/AF_XDPMemoryManagerFacts.cs

@@ -0,0 +1,86 @@
+using System;
+using Magma.AF_XDP.Internal;
+using Xunit;
+
+namespace Magma.AF_XDP.Facts
+{
+    public class AF_XDPMemoryManagerFacts
+    {
+        [Fact]
+        public void FrameSizeCalculationIsCorrect()
+        {
+            uint frameCount = 4096;
+            uint frameSize = 2048;
+            ulong expectedTotalSize = (ulong)frameCount * frameSize;
+
+            Assert.Equal(8388608UL, expectedTotalSize);
+        }
+
+        [Fact]
+        public void GetFrameAddressCalculationIsCorrect()
+        {
+            nint baseAddr = 0x1000;
+            uint frameSize = 2048;
+            ulong frameIndex = 10;
+
+            nint expectedAddr = baseAddr + (nint)(frameIndex * frameSize);
+
+            Assert.Equal(0x1000 + (10 * 2048), (long)expectedAddr);
+        }
+
+        [Fact(Skip = "Requires Linux with libbpf installed and XDP support")]
+        public unsafe void CanCreateMemoryManager()
+        {
+            uint frameCount = 4096;
+            uint frameSize = 2048;
+
+            using (var manager = new AF_XDPMemoryManager(frameCount, frameSize))
+            {
+                Assert.NotEqual(0, manager.Umem);
+                Assert.Equal(frameSize, manager.FrameSize);
+            }
+        }
+
+        [Fact(Skip = "Requires Linux with libbpf installed and XDP support")]
+        public unsafe void CanGetFrameAddress()
+        {
+            uint frameCount = 4096;
+            uint frameSize = 2048;
+
+            using (var manager = new AF_XDPMemoryManager(frameCount, frameSize))
+            {
+                nint addr0 = manager.GetFrameAddress(0);
+                nint addr1 = manager.GetFrameAddress(1);
+
+                Assert.NotEqual(0, addr0);
+                Assert.Equal(addr0 + (nint)frameSize, addr1);
+            }
+        }
+
+        [Fact(Skip = "Requires Linux with libbpf installed and XDP support")]
+        public unsafe void CanGetFrameMemory()
+        {
+            uint frameCount = 4096;
+            uint frameSize = 2048;
+
+            using (var manager = new AF_XDPMemoryManager(frameCount, frameSize))
+            {
+                var memory = manager.GetFrameMemory(0);
+
+                Assert.Equal((int)frameSize, memory.Length);
+            }
+        }
+
+        [Fact(Skip = "Requires Linux with libbpf installed and XDP support")]
+        public unsafe void DisposalCleansUpResources()
+        {
+            uint frameCount = 4096;
+            uint frameSize = 2048;
+
+            var manager = new AF_XDPMemoryManager(frameCount, frameSize);
+            manager.Dispose();
+
+            Assert.Equal(0, manager.Umem);
+        }
+    }
+}

test/Magma.AF_XDP.Facts/AF_XDPTransportFacts.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Magma.AF_XDP;
+using Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions.Internal;
+using Xunit;
+
+namespace Magma.AF_XDP.Facts
+{
+    public class AF_XDPTransportFacts
+    {
+        [Fact]
+        public void CanCreateTransportWithEndpoint()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var options = new AF_XDPTransportOptions { InterfaceName = "eth0" };
+            var dispatcher = new MockConnectionDispatcher();
+
+            var transport = new AF_XDPTransport(endpoint, options, dispatcher);
+
+            Assert.NotNull(transport);
+        }
+
+        [Fact]
+        public void ConstructorThrowsOnNullEndpoint()
+        {
+            var options = new AF_XDPTransportOptions { InterfaceName = "eth0" };
+            var dispatcher = new MockConnectionDispatcher();
+
+            Assert.Throws<ArgumentNullException>(() =>
+                new AF_XDPTransport(null, options, dispatcher));
+        }
+
+        [Fact]
+        public void ConstructorThrowsOnNullOptions()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var dispatcher = new MockConnectionDispatcher();
+
+            Assert.Throws<ArgumentNullException>(() =>
+                new AF_XDPTransport(endpoint, (AF_XDPTransportOptions)null, dispatcher));
+        }
+
+        [Fact]
+        public void ConstructorThrowsOnNullDispatcher()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var options = new AF_XDPTransportOptions { InterfaceName = "eth0" };
+
+            Assert.Throws<ArgumentNullException>(() =>
+                new AF_XDPTransport(endpoint, options, null));
+        }
+
+        [Fact]
+        public void CanCreateTransportWithInterfaceName()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var dispatcher = new MockConnectionDispatcher();
+
+            var transport = new AF_XDPTransport(endpoint, "eth0", dispatcher);
+
+            Assert.NotNull(transport);
+        }
+
+        [Fact(Skip = "Requires Linux with XDP-capable NIC and root privileges")]
+        public async Task CanBindTransport()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var options = new AF_XDPTransportOptions { InterfaceName = "eth0" };
+            var dispatcher = new MockConnectionDispatcher();
+
+            var transport = new AF_XDPTransport(endpoint, options, dispatcher);
+
+            await transport.BindAsync();
+            await transport.StopAsync();
+        }
+
+        [Fact(Skip = "Requires Linux with XDP-capable NIC and root privileges")]
+        public async Task CanUnbindTransport()
+        {
+            var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 8080);
+            var options = new AF_XDPTransportOptions { InterfaceName = "eth0" };
+            var dispatcher = new MockConnectionDispatcher();
+
+            var transport = new AF_XDPTransport(endpoint, options, dispatcher);
+
+            await transport.BindAsync();
+            await transport.UnbindAsync();
+            await transport.StopAsync();
+        }
+
+        private class MockConnectionDispatcher : IConnectionDispatcher
+        {
+            public void OnConnection(TransportConnection connection)
+            {
+            }
+        }
+    }
+}

test/Magma.AF_XDP.Facts/AF_XDPTransportOptionsFacts.cs

@@ -0,0 +1,90 @@
+using System;
+using Magma.AF_XDP;
+using Xunit;
+
+namespace Magma.AF_XDP.Facts
+{
+    public class AF_XDPTransportOptionsFacts
+    {
+        [Fact]
+        public void DefaultValuesAreCorrect()
+        {
+            var options = new AF_XDPTransportOptions();
+
+            Assert.Equal(0, options.QueueId);
+            Assert.True(options.UseZeroCopy);
+            Assert.Equal(4096, options.UmemFrameCount);
+            Assert.Equal(2048, options.FrameSize);
+            Assert.Equal(2048, options.RxRingSize);
+            Assert.Equal(2048, options.TxRingSize);
+        }
+
+        [Fact]
+        public void CanSetInterfaceName()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                InterfaceName = "eth0"
+            };
+
+            Assert.Equal("eth0", options.InterfaceName);
+        }
+
+        [Fact]
+        public void CanSetQueueId()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                QueueId = 5
+            };
+
+            Assert.Equal(5, options.QueueId);
+        }
+
+        [Fact]
+        public void CanDisableZeroCopy()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                UseZeroCopy = false
+            };
+
+            Assert.False(options.UseZeroCopy);
+        }
+
+        [Fact]
+        public void CanSetUmemFrameCount()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                UmemFrameCount = 8192
+            };
+
+            Assert.Equal(8192, options.UmemFrameCount);
+        }
+
+        [Fact]
+        public void CanSetFrameSize()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                FrameSize = 4096
+            };
+
+            Assert.Equal(4096, options.FrameSize);
+        }
+
+        [Fact]
+        public void CanSetRingSizes()
+        {
+            var options = new AF_XDPTransportOptions
+            {
+                RxRingSize = 4096,
+                TxRingSize = 1024
+            };
+
+            Assert.Equal(4096, options.RxRingSize);
+            Assert.Equal(1024, options.TxRingSize);
+        }
+    }
+}