From e164ad1a3ccae1caa55cd47e9d9124546510e659 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 14:43:27 +0800
Subject: [PATCH 1/7] Add Assert for TlsHandler.MediationStream

---
 .../Tls/TlsHandler.MediationStream.NetCore.cs                | 5 +++++
 .../Tls/TlsHandler.MediationStream.NetFx.cs                  | 3 +++
 .../Tls/TlsHandler.MediationStream.NetStandard20.cs          | 3 +++
 3 files changed, 11 insertions(+)

diff --git a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetCore.cs b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetCore.cs
index 766e2df02..4db76b0d3 100644
--- a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetCore.cs
+++ b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetCore.cs
@@ -39,6 +39,7 @@ partial class MediationStream
 
             public void SetSource(in ReadOnlyMemory<byte> source)
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = source;
                 _inputOffset = 0;
                 _inputLength = 0;
@@ -46,7 +47,9 @@ public void SetSource(in ReadOnlyMemory<byte> source)
 
             public void ResetSource()
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = null;
+                _inputOffset = 0;
                 _inputLength = 0;
             }
 
@@ -60,6 +63,7 @@ public void ExpandSource(int count)
                 if (sslBuffer.IsEmpty)
                 {
                     // there is no pending read operation - keep for future
+                    Debug.Assert(_readCompletionSource == null);
                     return;
                 }
                 _sslOwnedBuffer = default;
@@ -87,6 +91,7 @@ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken
                     return new ValueTask<int>(read);
                 }
 
+                Debug.Assert(_readCompletionSource == null);
                 Debug.Assert(_sslOwnedBuffer.IsEmpty);
                 // take note of buffer - we will pass bytes there once available
                 _sslOwnedBuffer = buffer;
diff --git a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetFx.cs b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetFx.cs
index cd6de86cd..8694f8d0b 100644
--- a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetFx.cs
+++ b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetFx.cs
@@ -45,6 +45,7 @@ partial class MediationStream
 
             public void SetSource(byte[] source, int offset)
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = source;
                 _inputStartOffset = offset;
                 _inputOffset = 0;
@@ -53,7 +54,9 @@ public void SetSource(byte[] source, int offset)
 
             public void ResetSource()
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = null;
+                _inputOffset = 0;
                 _inputLength = 0;
             }
 
diff --git a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetStandard20.cs b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetStandard20.cs
index c337ded64..d6c407734 100644
--- a/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetStandard20.cs
+++ b/src/DotNetty.Handlers/Tls/TlsHandler.MediationStream.NetStandard20.cs
@@ -39,6 +39,7 @@ partial class MediationStream
 
             public void SetSource(byte[] source, int offset)
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = source;
                 _inputStartOffset = offset;
                 _inputOffset = 0;
@@ -47,7 +48,9 @@ public void SetSource(byte[] source, int offset)
 
             public void ResetSource()
             {
+                Debug.Assert(SourceReadableBytes == 0);
                 _input = null;
+                _inputOffset = 0;
                 _inputLength = 0;
             }
 

From 090b92dbe5729e03efe2d79f6e8e6cf209fffd13 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 19:39:07 +0800
Subject: [PATCH 2/7] The old dotnetty.com.pfx use Sha1+RSA1024 instead of
 Sha256+RSA2048, and seems obsoleted and no longer work on net5.0+ubuntu20.04

Generated with
```
openssl genrsa -out ssl.key 2048
openssl req -new -x509 -key ssl.key -out dotnetty.com.cer -days 3650 -subj /CN=dotnetty.com
openssl req -new -x509 -key ssl.key -out contoso.com.cer -days 3650 -subj /CN=contoso.com
openssl pkcs12 -export -out dotnetty.com.pfx -inkey ssl.key -in dotnetty.com.cer
openssl pkcs12 -export -out contoso.com.pfx -inkey ssl.key -in contoso.com.cer
```
password="password"
---
 shared/contoso.com.pfx  | Bin 2503 -> 2389 bytes
 shared/dotnetty.com.pfx | Bin 1710 -> 2389 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/shared/contoso.com.pfx b/shared/contoso.com.pfx
index bacddeff76af91e5bae2b9bc3962c7b85d2e0602..a864470785b837a487d8ed30c906012839f6af22 100644
GIT binary patch
literal 2389
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
EFEU+Z_5c6?

literal 2503
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

diff --git a/shared/dotnetty.com.pfx b/shared/dotnetty.com.pfx
index 4b2c4f245a371ff97c9bd98570f996d3e764fb9a..27fed55b44d0b8e03d7b4e4c853a8efb16297f7f 100644
GIT binary patch
literal 2389
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
F@?Svua9IEV

literal 1710
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


From 8ade2abdb55b9c6a1703d3b29b96025c8314adb2 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 21:47:21 +0800
Subject: [PATCH 3/7] Ignore SslProtocols not avaliable on current platform in
 TlsHandlerTest

---
 .../DotNetty.Handlers.Tests/SniHandlerTest.cs |  24 +--
 .../DotNetty.Handlers.Tests/TlsHandlerTest.cs | 153 ++++++++++++++----
 .../TestResourceHelper.cs                     |  38 +++--
 3 files changed, 156 insertions(+), 59 deletions(-)

diff --git a/test/DotNetty.Handlers.Tests/SniHandlerTest.cs b/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
index 9ca2e9ca2..605dd4c71 100644
--- a/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
@@ -32,11 +32,7 @@ static SniHandlerTest()
             X509Certificate2 tlsCertificate = TestResourceHelper.GetTestCertificate();
             X509Certificate2 tlsCertificate2 = TestResourceHelper.GetTestCertificate2();
 
-            //#if NETCOREAPP_3_0_GREATER
-            //            SslProtocols serverProtocol = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? SslProtocols.Tls13 : SslProtocols.Tls12;
-            //#else
-            SslProtocols serverProtocol = SslProtocols.Tls12;
-            //#endif
+            SslProtocols serverProtocol = SslProtocols.None;
             SettingMap[tlsCertificate.GetNameInfo(X509NameType.DnsName, false)] = new ServerTlsSettings(tlsCertificate, false, false, serverProtocol);
             SettingMap[tlsCertificate2.GetNameInfo(X509NameType.DnsName, false)] = new ServerTlsSettings(tlsCertificate2, false, false, serverProtocol);
         }
@@ -53,11 +49,7 @@ public static IEnumerable<object[]> GetTlsReadTestData()
                 new[] { 1 }
             };
             var boolToggle = new[] { false, true };
-            //#if NETCOREAPP_3_0_GREATER
-            //            var protocols = new[] { RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? SslProtocols.Tls13 : SslProtocols.Tls12 };
-            //#else
-            var protocols = new[] { SslProtocols.Tls12 };
-            //#endif
+            var protocols = new[] { SslProtocols.None };
             var writeStrategyFactories = new Func<IWriteStrategy>[]
             {
         () => new AsIsWriteStrategy()
@@ -106,7 +98,8 @@ public async Task TlsRead(int[] frameLengths, bool isClient, IWriteStrategy writ
 #pragma warning disable CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
                 await ReadOutboundAsync(async () => ch.ReadInbound<IByteBuffer>(), expectedBuffer.ReadableBytes, finalReadBuffer, TestTimeout);
 #pragma warning restore CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
-                Assert.True(ByteBufferUtil.Equals(expectedBuffer, finalReadBuffer), $"---Expected:\n{ByteBufferUtil.PrettyHexDump(expectedBuffer)}\n---Actual:\n{ByteBufferUtil.PrettyHexDump(finalReadBuffer)}");
+                if (!ByteBufferUtil.Equals(expectedBuffer, finalReadBuffer))
+                    Assert.True(false, $"---Expected:\n{ByteBufferUtil.PrettyHexDump(expectedBuffer)}\n---Actual:\n{ByteBufferUtil.PrettyHexDump(finalReadBuffer)}");
 
                 if (!isClient)
                 {
@@ -131,11 +124,7 @@ public static IEnumerable<object[]> GetTlsWriteTestData()
                 new[] { 1 }
             };
             var boolToggle = new[] { false, true };
-            //#if NETCOREAPP_3_0_GREATER
-            //            var protocols = new[] { RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? SslProtocols.Tls13 : SslProtocols.Tls12 };
-            //#else
-            var protocols = new[] { SslProtocols.Tls12 };
-            //#endif
+            var protocols = new[] { SslProtocols.None };
 
             return
                 from frameLengths in lengthVariations
@@ -186,7 +175,8 @@ await ReadOutboundAsync(
                         return Unpooled.WrappedBuffer(readBuffer, 0, read);
                     },
                     expectedBuffer.ReadableBytes, finalReadBuffer, TestTimeout);
-                Assert.True(ByteBufferUtil.Equals(expectedBuffer, finalReadBuffer), $"---Expected:\n{ByteBufferUtil.PrettyHexDump(expectedBuffer)}\n---Actual:\n{ByteBufferUtil.PrettyHexDump(finalReadBuffer)}");
+                if (!ByteBufferUtil.Equals(expectedBuffer, finalReadBuffer))
+                    Assert.True(false, $"---Expected:\n{ByteBufferUtil.PrettyHexDump(expectedBuffer)}\n---Actual:\n{ByteBufferUtil.PrettyHexDump(finalReadBuffer)}");
 
                 if (!isClient)
                 {
diff --git a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
index 71da5f07a..0431c6e91 100644
--- a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
@@ -7,8 +7,9 @@ namespace DotNetty.Handlers.Tests
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Linq;
+    using System.Net;
     using System.Net.Security;
-    using System.Runtime.InteropServices;
+    using System.Net.Sockets;
     using System.Security.Authentication;
     using System.Security.Cryptography.X509Certificates;
     using System.Threading.Tasks;
@@ -47,25 +48,30 @@ public static IEnumerable<object[]> GetTlsReadTestData()
                     Enumerable.Repeat(0, 30).Select(_ => random.Next(0, 17000)).ToArray()
                 };
             var boolToggle = new[] { false, true };
-            var protocols = new List<Tuple<SslProtocols, SslProtocols>>();
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                protocols.Add(Tuple.Create(SslProtocols.Tls, SslProtocols.Tls));
-                protocols.Add(Tuple.Create(SslProtocols.Tls11, SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12, SslProtocols.Tls12));
+            var protocols = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
+            protocols.Add((SslProtocols.Tls, SslProtocols.Tls));
+            protocols.Add((SslProtocols.Tls11, SslProtocols.Tls11));
+            protocols.Add((SslProtocols.Tls12, SslProtocols.Tls12));
 #if NETCOREAPP_3_0_GREATER
-                //protocols.Add(Tuple.Create(SslProtocols.Tls13, SslProtocols.Tls13));
+            var tls13 = SslProtocols.Tls13;
+            protocols.Add((tls13, tls13));
+#else
+            var tls13 = SslProtocols.None;
 #endif
-                protocols.Add(Tuple.Create(SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
+            if ((Platform.SupportedSslProtocols & tls13) != SslProtocols.None)
+            {
+                //Tls and Tls11 maybe unavailable in new platforms
+                protocols.Add((SslProtocols.Tls12 | tls13, SslProtocols.Tls11 | SslProtocols.Tls12));
+                protocols.Add((SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls12 | tls13));
             }
             else
             {
-                protocols.Add(Tuple.Create(SslProtocols.Tls11, SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12, SslProtocols.Tls12));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12 | SslProtocols.Tls11, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
+                protocols.Add((SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
+                protocols.Add((SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
             }
+
+            protocols = FilterPlatformAvailableProtocols(protocols);
+
             var writeStrategyFactories = new Func<IWriteStrategy>[]
             {
                 () => new AsIsWriteStrategy(),
@@ -79,7 +85,7 @@ from frameLengths in lengthVariations
                 from isClient in boolToggle
                 from writeStrategyFactory in writeStrategyFactories
                 from protocol in protocols
-                select new object[] { frameLengths, isClient, writeStrategyFactory(), protocol.Item1, protocol.Item2 };
+                select new object[] { frameLengths, isClient, writeStrategyFactory(), protocol.serverProtocol, protocol.clientProtocol };
         }
 
 
@@ -147,31 +153,35 @@ public static IEnumerable<object[]> GetTlsWriteTestData()
                     Enumerable.Repeat(0, 30).Select(_ => random.Next(0, 10) < 2 ? -1 : random.Next(0, 17000)).ToArray()
                 };
             var boolToggle = new[] { false, true };
-            var protocols = new List<Tuple<SslProtocols, SslProtocols>>();
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                protocols.Add(Tuple.Create(SslProtocols.Tls, SslProtocols.Tls));
-                protocols.Add(Tuple.Create(SslProtocols.Tls11, SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12, SslProtocols.Tls12));
+            var protocols = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
+            protocols.Add((SslProtocols.Tls, SslProtocols.Tls));
+            protocols.Add((SslProtocols.Tls11, SslProtocols.Tls11));
+            protocols.Add((SslProtocols.Tls12, SslProtocols.Tls12));
 #if NETCOREAPP_3_0_GREATER
-                //protocols.Add(Tuple.Create(SslProtocols.Tls13, SslProtocols.Tls13));
+            var tls13 = SslProtocols.Tls13;
+            protocols.Add((tls13, tls13));
+#else
+            var tls13 = SslProtocols.None;
 #endif
-                protocols.Add(Tuple.Create(SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
+            if ((Platform.SupportedSslProtocols & tls13) != SslProtocols.None)
+            {
+                //Tls and Tls11 maybe unavailable in new platforms
+                protocols.Add((SslProtocols.Tls12 | tls13, SslProtocols.Tls11 | SslProtocols.Tls12));
+                protocols.Add((SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls12 | tls13));
             }
             else
             {
-                protocols.Add(Tuple.Create(SslProtocols.Tls11, SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12, SslProtocols.Tls12));
-                protocols.Add(Tuple.Create(SslProtocols.Tls12 | SslProtocols.Tls11, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add(Tuple.Create(SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
+                protocols.Add((SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
+                protocols.Add((SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
             }
 
+            protocols = FilterPlatformAvailableProtocols(protocols);
+
             return
                 from frameLengths in lengthVariations
                 from isClient in boolToggle
                 from protocol in protocols
-                select new object[] { frameLengths, isClient, protocol.Item1, protocol.Item2 };
+                select new object[] { frameLengths, isClient, protocol.serverProtocol, protocol.clientProtocol };
         }
 
         [Theory]
@@ -232,6 +242,31 @@ await ReadOutboundAsync(
             }
         }
 
+        static List<(SslProtocols serverProtocol, SslProtocols clientProtocol)> FilterPlatformAvailableProtocols(List<(SslProtocols serverProtocol, SslProtocols clientProtocol)> protocols)
+        {
+            var set = new HashSet<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
+            var list = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>(protocols.Count + 1);
+
+            //Ensure there is at least one test available(SslProtocols.None: Allows the operating system to choose the best protocol to use, and to block protocols that are not secure.)
+            list.Add((SslProtocols.None, SslProtocols.None));
+
+            var supportedSslProtocols = Platform.SupportedSslProtocols;
+            if (supportedSslProtocols != SslProtocols.None)
+            {
+                foreach (var cur in protocols)
+                {
+                    var (serverProtocol, clientProtocol) = cur;
+                    serverProtocol &= supportedSslProtocols;
+                    clientProtocol &= supportedSslProtocols;
+                    if ((serverProtocol & clientProtocol) == SslProtocols.None)
+                        continue;
+                    if (set.Add((serverProtocol, clientProtocol)))
+                        list.Add((serverProtocol, clientProtocol));
+                }
+            }
+            return list;
+        }
+
         static async Task<Tuple<EmbeddedChannel, SslStream>> SetupStreamAndChannelAsync(bool isClient, IEventExecutor executor, IWriteStrategy writeStrategy, SslProtocols serverProtocol, SslProtocols clientProtocol, List<Task> writeTasks)
         {
             X509Certificate2 tlsCertificate = TestResourceHelper.GetTestCertificate();
@@ -378,5 +413,65 @@ public override void ChannelActive(IChannelHandlerContext context)
                 }
             }
         }
+
+        public static class Platform
+        {
+            public static readonly SslProtocols SupportedSslProtocols;
+            static Platform()
+            {
+                SslProtocols protocol = 0;
+                protocol |= CheckSslProtocol(SslProtocols.Tls);
+                protocol |= CheckSslProtocol(SslProtocols.Tls11);
+                protocol |= CheckSslProtocol(SslProtocols.Tls12);
+#if NETCOREAPP_3_0_GREATER
+                protocol |= CheckSslProtocol(SslProtocols.Tls13);
+#endif
+                SupportedSslProtocols = protocol;
+            }
+
+            private static SslProtocols CheckSslProtocol(SslProtocols protocol)
+            {
+                X509Certificate2 tlsCertificate = TestResourceHelper.GetTestCertificate();
+                string targetHost = tlsCertificate.GetNameInfo(X509NameType.SimpleName, false);
+                try
+                {
+                    using (var server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+                    {
+                        server.Bind(new IPEndPoint(IPAddress.Loopback, 0));
+                        server.Listen(1);
+                        using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+                        {
+                            client.Connect(server.LocalEndPoint);
+                            using (var a = new SslStream(new NetworkStream(server.Accept(), ownsSocket: true)))
+                            using (var b = new SslStream(new NetworkStream(client, ownsSocket: true), false, (sender, certificate, chain, sslPolicyErrors) => true))
+                            {
+                                Task.WhenAll(
+                                    Task.Run(async () =>
+                                    {
+                                        using (b)
+                                        {
+                                            await b.AuthenticateAsClientAsync(targetHost, null, protocol, false);
+                                            Debug.Assert(b.SslProtocol == protocol);
+                                        }
+                                    }),
+                                    Task.Run(async () =>
+                                    {
+                                        using (a)
+                                        {
+                                            await a.AuthenticateAsServerAsync(tlsCertificate, false, protocol, false);
+                                            Debug.Assert(a.SslProtocol == protocol);
+                                        }
+                                    })).WithTimeout(TimeSpan.FromSeconds(1)).GetAwaiter().GetResult();
+                            }
+                        }
+                    }
+                    return protocol;
+                }
+                catch (AuthenticationException)
+                {
+                    return SslProtocols.None;
+                }
+            }
+        }
     }
 }
diff --git a/test/DotNetty.Tests.Common/TestResourceHelper.cs b/test/DotNetty.Tests.Common/TestResourceHelper.cs
index fae5670ec..a1418a07e 100644
--- a/test/DotNetty.Tests.Common/TestResourceHelper.cs
+++ b/test/DotNetty.Tests.Common/TestResourceHelper.cs
@@ -9,30 +9,42 @@ namespace DotNetty.Tests.Common
 
     public static class TestResourceHelper
     {
+        static X509Certificate2 _testCert;
+        static X509Certificate2 _testCert2;
+
         public static X509Certificate2 GetTestCertificate()
         {
-            byte[] certData;
-            using (Stream resStream = typeof(TestResourceHelper).GetTypeInfo().Assembly.GetManifestResourceStream(typeof(TestResourceHelper).Namespace + "." + "dotnetty.com.pfx"))
-            using (var memStream = new MemoryStream())
+            var testCert = _testCert;
+            if (testCert is null)
             {
-                resStream.CopyTo(memStream);
-                certData = memStream.ToArray();
+                byte[] certData;
+                using (Stream resStream = typeof(TestResourceHelper).GetTypeInfo().Assembly.GetManifestResourceStream(typeof(TestResourceHelper).Namespace + "." + "dotnetty.com.pfx"))
+                using (var memStream = new MemoryStream())
+                {
+                    resStream.CopyTo(memStream);
+                    certData = memStream.ToArray();
+                }
+                testCert = _testCert = new X509Certificate2(certData, "password");
             }
 
-            return new X509Certificate2(certData, "password");
+            return testCert;
         }
 
         public static X509Certificate2 GetTestCertificate2()
         {
-            byte[] certData;
-            using (Stream resStream = typeof(TestResourceHelper).GetTypeInfo().Assembly.GetManifestResourceStream(typeof(TestResourceHelper).Namespace + "." + "contoso.com.pfx"))
-            using (var memStream = new MemoryStream())
+            var testCert2 = _testCert2;
+            if (testCert2 is null)
             {
-                resStream.CopyTo(memStream);
-                certData = memStream.ToArray();
+                byte[] certData;
+                using (Stream resStream = typeof(TestResourceHelper).GetTypeInfo().Assembly.GetManifestResourceStream(typeof(TestResourceHelper).Namespace + "." + "contoso.com.pfx"))
+                using (var memStream = new MemoryStream())
+                {
+                    resStream.CopyTo(memStream);
+                    certData = memStream.ToArray();
+                }
+                testCert2 = _testCert2 = new X509Certificate2(certData, "password");
             }
-
-            return new X509Certificate2(certData, "password");
+            return testCert2;
         }
     }
 }
\ No newline at end of file

From 6cc270d2f7b4ca59621b1cfb0af99cbf62450628 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 22:05:20 +0800
Subject: [PATCH 4/7] Move test of SslProtocols to an independent group, no
 need to run too many tests for it

---
 .../DotNetty.Handlers.Tests/TlsHandlerTest.cs | 101 +++++++++++-------
 1 file changed, 63 insertions(+), 38 deletions(-)

diff --git a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
index 0431c6e91..9a965b466 100644
--- a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
@@ -48,6 +48,49 @@ public static IEnumerable<object[]> GetTlsReadTestData()
                     Enumerable.Repeat(0, 30).Select(_ => random.Next(0, 17000)).ToArray()
                 };
             var boolToggle = new[] { false, true };
+            var protocols = new (SslProtocols serverProtocol, SslProtocols clientProtocol)[] { (SslProtocols.None, SslProtocols.None) };
+
+            var writeStrategyFactories = new Func<IWriteStrategy>[]
+            {
+                () => new AsIsWriteStrategy(),
+                () => new BatchingWriteStrategy(1, TimeSpan.FromMilliseconds(20), true),
+                () => new BatchingWriteStrategy(4096, TimeSpan.FromMilliseconds(20), true),
+                () => new BatchingWriteStrategy(32 * 1024, TimeSpan.FromMilliseconds(20), false)
+            };
+
+            return
+                from frameLengths in lengthVariations
+                from isClient in boolToggle
+                from writeStrategyFactory in writeStrategyFactories
+                from protocol in protocols
+                select new object[] { frameLengths, isClient, writeStrategyFactory(), protocol.serverProtocol, protocol.clientProtocol };
+        }
+
+        public static IEnumerable<object[]> GetTlsReadTestProtocol()
+        {
+            var lengthVariations =
+                new[]
+                {
+                    new[] { 1 },
+                };
+            var boolToggle = new[] { false, true };
+            var protocols = GetTlsTestProtocol();
+
+            var writeStrategyFactories = new Func<IWriteStrategy>[]
+            {
+                () => new AsIsWriteStrategy()
+            };
+
+            return
+                from frameLengths in lengthVariations
+                from isClient in boolToggle
+                from writeStrategyFactory in writeStrategyFactories
+                from protocol in protocols
+                select new object[] { frameLengths, isClient, writeStrategyFactory(), protocol.serverProtocol, protocol.clientProtocol };
+        }
+
+        static List<(SslProtocols serverProtocol, SslProtocols clientProtocol)> GetTlsTestProtocol()
+        {
             var protocols = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
             protocols.Add((SslProtocols.Tls, SslProtocols.Tls));
             protocols.Add((SslProtocols.Tls11, SslProtocols.Tls11));
@@ -71,26 +114,12 @@ public static IEnumerable<object[]> GetTlsReadTestData()
             }
 
             protocols = FilterPlatformAvailableProtocols(protocols);
-
-            var writeStrategyFactories = new Func<IWriteStrategy>[]
-            {
-                () => new AsIsWriteStrategy(),
-                () => new BatchingWriteStrategy(1, TimeSpan.FromMilliseconds(20), true),
-                () => new BatchingWriteStrategy(4096, TimeSpan.FromMilliseconds(20), true),
-                () => new BatchingWriteStrategy(32 * 1024, TimeSpan.FromMilliseconds(20), false)
-            };
-
-            return
-                from frameLengths in lengthVariations
-                from isClient in boolToggle
-                from writeStrategyFactory in writeStrategyFactories
-                from protocol in protocols
-                select new object[] { frameLengths, isClient, writeStrategyFactory(), protocol.serverProtocol, protocol.clientProtocol };
+            return protocols;
         }
 
-
         [Theory]
         [MemberData(nameof(GetTlsReadTestData))]
+        [MemberData(nameof(GetTlsReadTestProtocol))]
         public async Task TlsRead(int[] frameLengths, bool isClient, IWriteStrategy writeStrategy, SslProtocols serverProtocol, SslProtocols clientProtocol)
         {
             this.Output.WriteLine($"frameLengths: {string.Join(", ", frameLengths)}");
@@ -153,29 +182,24 @@ public static IEnumerable<object[]> GetTlsWriteTestData()
                     Enumerable.Repeat(0, 30).Select(_ => random.Next(0, 10) < 2 ? -1 : random.Next(0, 17000)).ToArray()
                 };
             var boolToggle = new[] { false, true };
-            var protocols = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
-            protocols.Add((SslProtocols.Tls, SslProtocols.Tls));
-            protocols.Add((SslProtocols.Tls11, SslProtocols.Tls11));
-            protocols.Add((SslProtocols.Tls12, SslProtocols.Tls12));
-#if NETCOREAPP_3_0_GREATER
-            var tls13 = SslProtocols.Tls13;
-            protocols.Add((tls13, tls13));
-#else
-            var tls13 = SslProtocols.None;
-#endif
-            if ((Platform.SupportedSslProtocols & tls13) != SslProtocols.None)
-            {
-                //Tls and Tls11 maybe unavailable in new platforms
-                protocols.Add((SslProtocols.Tls12 | tls13, SslProtocols.Tls11 | SslProtocols.Tls12));
-                protocols.Add((SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls12 | tls13));
-            }
-            else
-            {
-                protocols.Add((SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add((SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
-            }
+            var protocols = new (SslProtocols serverProtocol, SslProtocols clientProtocol)[] { (SslProtocols.None, SslProtocols.None) };
 
-            protocols = FilterPlatformAvailableProtocols(protocols);
+            return
+                from frameLengths in lengthVariations
+                from isClient in boolToggle
+                from protocol in protocols
+                select new object[] { frameLengths, isClient, protocol.serverProtocol, protocol.clientProtocol };
+        }
+
+        public static IEnumerable<object[]> GetTlsWriteTestProtocol()
+        {
+            var lengthVariations =
+                new[]
+                {
+                    new[] { 1 }
+                };
+            var boolToggle = new[] { false, true };
+            var protocols = GetTlsTestProtocol();
 
             return
                 from frameLengths in lengthVariations
@@ -186,6 +210,7 @@ from protocol in protocols
 
         [Theory]
         [MemberData(nameof(GetTlsWriteTestData))]
+        [MemberData(nameof(GetTlsWriteTestProtocol))]
         public async Task TlsWrite(int[] frameLengths, bool isClient, SslProtocols serverProtocol, SslProtocols clientProtocol)
         {
             this.Output.WriteLine($"frameLengths: {string.Join(", ", frameLengths)}");

From 9c9e5e49801ab98af942389510ddb33b8c241011 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 22:43:29 +0800
Subject: [PATCH 5/7] Add an assert to ensure proper protocol is used by ssl
 handshake

---
 test/DotNetty.Handlers.Tests/TlsHandlerTest.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
index 9a965b466..0679d4dd2 100644
--- a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
@@ -343,6 +343,9 @@ static async Task<Tuple<EmbeddedChannel, SslStream>> SetupStreamAndChannelAsync(
             {
                 await Task.Run(() => driverStream.AuthenticateAsClientAsync(targetHost, null, clientProtocol, false)).WithTimeout(TimeSpan.FromSeconds(5));
             }
+            if ((clientProtocol & serverProtocol) != SslProtocols.None)
+                Assert.True((clientProtocol & serverProtocol & driverStream.SslProtocol) != SslProtocols.None, "Unexpected ssl handshake protocol: " + driverStream.SslProtocol);
+
             writeTasks.Clear();
 
             return Tuple.Create(ch, driverStream);

From e0802baa2bf801c6c5dc85064f5bbaaead2c8fb6 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Sun, 23 May 2021 23:09:43 +0800
Subject: [PATCH 6/7] Rework ssl handShake test with new assert

---
 .../DotNetty.Handlers.Tests/TlsHandlerTest.cs | 107 ++++++++++--------
 1 file changed, 60 insertions(+), 47 deletions(-)

diff --git a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
index 0679d4dd2..907ba25b3 100644
--- a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
@@ -92,25 +92,21 @@ from protocol in protocols
         static List<(SslProtocols serverProtocol, SslProtocols clientProtocol)> GetTlsTestProtocol()
         {
             var protocols = new List<(SslProtocols serverProtocol, SslProtocols clientProtocol)>();
-            protocols.Add((SslProtocols.Tls, SslProtocols.Tls));
-            protocols.Add((SslProtocols.Tls11, SslProtocols.Tls11));
-            protocols.Add((SslProtocols.Tls12, SslProtocols.Tls12));
-#if NETCOREAPP_3_0_GREATER
-            var tls13 = SslProtocols.Tls13;
-            protocols.Add((tls13, tls13));
-#else
-            var tls13 = SslProtocols.None;
-#endif
-            if ((Platform.SupportedSslProtocols & tls13) != SslProtocols.None)
+            var supportedProtocolList = Platform.SupportedSslProtocolList;
+            foreach (var cur in supportedProtocolList)
             {
-                //Tls and Tls11 maybe unavailable in new platforms
-                protocols.Add((SslProtocols.Tls12 | tls13, SslProtocols.Tls11 | SslProtocols.Tls12));
-                protocols.Add((SslProtocols.Tls11 | SslProtocols.Tls12, SslProtocols.Tls12 | tls13));
+                protocols.Add((cur, cur));
             }
-            else
+            int handShakeTestCnt = 0;
+            var supportedProtocols = Platform.AllSupportedSslProtocols;
+            foreach (var cur in supportedProtocolList)
             {
-                protocols.Add((SslProtocols.Tls12 | SslProtocols.Tls, SslProtocols.Tls12 | SslProtocols.Tls11));
-                protocols.Add((SslProtocols.Tls | SslProtocols.Tls12, SslProtocols.Tls | SslProtocols.Tls11));
+                protocols.Add((cur, supportedProtocols));
+                protocols.Add((supportedProtocols, cur));
+
+                handShakeTestCnt++;
+                if (handShakeTestCnt >= 2)
+                    break;
             }
 
             protocols = FilterPlatformAvailableProtocols(protocols);
@@ -275,7 +271,7 @@ await ReadOutboundAsync(
             //Ensure there is at least one test available(SslProtocols.None: Allows the operating system to choose the best protocol to use, and to block protocols that are not secure.)
             list.Add((SslProtocols.None, SslProtocols.None));
 
-            var supportedSslProtocols = Platform.SupportedSslProtocols;
+            var supportedSslProtocols = Platform.AllSupportedSslProtocols;
             if (supportedSslProtocols != SslProtocols.None)
             {
                 foreach (var cur in protocols)
@@ -444,20 +440,34 @@ public override void ChannelActive(IChannelHandlerContext context)
 
         public static class Platform
         {
-            public static readonly SslProtocols SupportedSslProtocols;
+            public static readonly SslProtocols AllSupportedSslProtocols;
+            public static readonly IReadOnlyList<SslProtocols> SupportedSslProtocolList;
             static Platform()
             {
-                SslProtocols protocol = 0;
-                protocol |= CheckSslProtocol(SslProtocols.Tls);
-                protocol |= CheckSslProtocol(SslProtocols.Tls11);
-                protocol |= CheckSslProtocol(SslProtocols.Tls12);
+                var allProtocol = new[]
+                {
+                    SslProtocols.Tls,
+                    SslProtocols.Tls11,
+                    SslProtocols.Tls12,
 #if NETCOREAPP_3_0_GREATER
-                protocol |= CheckSslProtocol(SslProtocols.Tls13);
+                    SslProtocols.Tls13,
 #endif
-                SupportedSslProtocols = protocol;
+                };
+                var protocols = SslProtocols.None;
+                var list = new List<SslProtocols>();
+                foreach (var cur in allProtocol)
+                {
+                    if (CheckSslProtocol(cur))
+                    {
+                        protocols |= cur;
+                        list.Add(cur);
+                    }
+                }
+                AllSupportedSslProtocols = protocols;
+                SupportedSslProtocolList = list.AsReadOnly();
             }
 
-            private static SslProtocols CheckSslProtocol(SslProtocols protocol)
+            private static bool CheckSslProtocol(SslProtocols protocol)
             {
                 X509Certificate2 tlsCertificate = TestResourceHelper.GetTestCertificate();
                 string targetHost = tlsCertificate.GetNameInfo(X509NameType.SimpleName, false);
@@ -469,35 +479,38 @@ private static SslProtocols CheckSslProtocol(SslProtocols protocol)
                         server.Listen(1);
                         using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
                         {
-                            client.Connect(server.LocalEndPoint);
-                            using (var a = new SslStream(new NetworkStream(server.Accept(), ownsSocket: true)))
-                            using (var b = new SslStream(new NetworkStream(client, ownsSocket: true), false, (sender, certificate, chain, sslPolicyErrors) => true))
+                            Task.Run(async () =>
                             {
-                                Task.WhenAll(
-                                    Task.Run(async () =>
-                                    {
-                                        using (b)
+                                client.Connect(server.LocalEndPoint);
+                                using (var a = new SslStream(new NetworkStream(server.Accept(), ownsSocket: true)))
+                                using (var b = new SslStream(new NetworkStream(client, ownsSocket: true), false, (sender, certificate, chain, sslPolicyErrors) => true))
+                                {
+                                    await Task.WhenAll(
+                                        Task.Run(async () =>
                                         {
-                                            await b.AuthenticateAsClientAsync(targetHost, null, protocol, false);
-                                            Debug.Assert(b.SslProtocol == protocol);
-                                        }
-                                    }),
-                                    Task.Run(async () =>
-                                    {
-                                        using (a)
+                                            using (b)
+                                            {
+                                                await b.AuthenticateAsClientAsync(targetHost, null, protocol, false);
+                                                Debug.Assert(b.SslProtocol == protocol);
+                                            }
+                                        }),
+                                        Task.Run(async () =>
                                         {
-                                            await a.AuthenticateAsServerAsync(tlsCertificate, false, protocol, false);
-                                            Debug.Assert(a.SslProtocol == protocol);
-                                        }
-                                    })).WithTimeout(TimeSpan.FromSeconds(1)).GetAwaiter().GetResult();
-                            }
+                                            using (a)
+                                            {
+                                                await a.AuthenticateAsServerAsync(tlsCertificate, false, protocol, false);
+                                                Debug.Assert(a.SslProtocol == protocol);
+                                            }
+                                        }));
+                                }
+                            }).WithTimeout(TimeSpan.FromSeconds(1)).GetAwaiter().GetResult();
                         }
                     }
-                    return protocol;
+                    return true;
                 }
-                catch (AuthenticationException)
+                catch
                 {
-                    return SslProtocols.None;
+                    return false;
                 }
             }
         }

From ae2874b93f6a5215f5f83269a6abb1c11020bb22 Mon Sep 17 00:00:00 2001
From: SilverFox <yyjdelete@126.com>
Date: Mon, 24 May 2021 22:10:41 +0800
Subject: [PATCH 7/7] set DisableDiscoveryEnumeration = true for
 non-serializable MemberData

---
 .../HttpServerKeepAliveHandlerTest.cs         |  6 +-
 test/DotNetty.Codecs.Http2.Tests/HpackTest.cs |  2 +-
 .../RoundTripTests.cs                         |  2 +-
 .../DotNetty.Handlers.Tests/SniHandlerTest.cs |  2 +-
 .../DotNetty.Handlers.Tests/TlsHandlerTest.cs |  4 +-
 .../AbstractSocketShutdownOutputByPeerTest.cs |  4 +-
 .../CompositeBufferGatheringWriteTest.cs      | 16 +++---
 .../Transport/Socket/SocketAutoReadTest.cs    |  8 +--
 .../Transport/Socket/SocketBufReleaseTest.cs  |  8 +--
 .../Transport/Socket/SocketCancelWriteTest.cs |  8 +--
 .../SocketConditionalWritabilityTest.cs       |  8 +--
 .../Transport/Socket/SocketConnectTest.cs     | 16 +++---
 .../Socket/SocketDataReadInitialStateTest.cs  | 16 +++---
 .../Transport/Socket/SocketEchoTest.cs        | 56 +++++++++----------
 .../Socket/SocketExceptionHandlingTest.cs     |  8 +--
 .../Socket/SocketFixedLengthEchoTest.cs       | 16 +++---
 .../Socket/SocketGatheringWriteTest.cs        | 40 ++++++-------
 .../Transport/Socket/SocketHalfClosedTest.cs  | 14 ++---
 .../Transport/Socket/SocketReadPendingTest.cs |  8 +--
 .../Transport/Socket/SocketRstTest.cs         | 16 +++---
 .../Transport/Socket/SocketStringEchoTest.cs  | 16 +++---
 .../Socket/WriteBeforeRegisteredTest.cs       |  4 +-
 .../SocketDatagramChannelMulticastTest.cs     |  2 +-
 .../SocketDatagramChannelUnicastTest.cs       |  2 +-
 24 files changed, 141 insertions(+), 141 deletions(-)

diff --git a/test/DotNetty.Codecs.Http.Tests/HttpServerKeepAliveHandlerTest.cs b/test/DotNetty.Codecs.Http.Tests/HttpServerKeepAliveHandlerTest.cs
index 42c13e4cc..1007e809e 100644
--- a/test/DotNetty.Codecs.Http.Tests/HttpServerKeepAliveHandlerTest.cs
+++ b/test/DotNetty.Codecs.Http.Tests/HttpServerKeepAliveHandlerTest.cs
@@ -39,7 +39,7 @@ public static IEnumerable<object[]> GetKeepAliveCases() => new[]
         };
 
         [Theory]
-        [MemberData(nameof(GetKeepAliveCases))]
+        [MemberData(nameof(GetKeepAliveCases), DisableDiscoveryEnumeration = true)]
         public void KeepAlive(bool isKeepAliveResponseExpected, HttpVersion httpVersion, HttpResponseStatus responseStatus, string sendKeepAlive, int setSelfDefinedMessageLength, ICharSequence setResponseConnection)
         {
             var channel = new EmbeddedChannel(new HttpServerKeepAliveHandler());
@@ -66,7 +66,7 @@ public void KeepAlive(bool isKeepAliveResponseExpected, HttpVersion httpVersion,
         }
 
         [Theory]
-        [MemberData(nameof(GetKeepAliveCases))]
+        [MemberData(nameof(GetKeepAliveCases), DisableDiscoveryEnumeration = true)]
 #pragma warning disable xUnit1026 // Theory methods should use all of their parameters
         public void ConnectionCloseHeaderHandledCorrectly(bool isKeepAliveResponseExpected, HttpVersion httpVersion, HttpResponseStatus responseStatus, string sendKeepAlive, int setSelfDefinedMessageLength, ICharSequence setResponseConnection)
 #pragma warning restore xUnit1026 // Theory methods should use all of their parameters
@@ -85,7 +85,7 @@ public void ConnectionCloseHeaderHandledCorrectly(bool isKeepAliveResponseExpect
         }
 
         [Theory]
-        [MemberData(nameof(GetKeepAliveCases))]
+        [MemberData(nameof(GetKeepAliveCases), DisableDiscoveryEnumeration = true)]
         public void PipelineKeepAlive(bool isKeepAliveResponseExpected, HttpVersion httpVersion, HttpResponseStatus responseStatus, string sendKeepAlive, int setSelfDefinedMessageLength, ICharSequence setResponseConnection)
         {
             var channel = new EmbeddedChannel(new HttpServerKeepAliveHandler());
diff --git a/test/DotNetty.Codecs.Http2.Tests/HpackTest.cs b/test/DotNetty.Codecs.Http2.Tests/HpackTest.cs
index 957269d88..6d49eef8f 100644
--- a/test/DotNetty.Codecs.Http2.Tests/HpackTest.cs
+++ b/test/DotNetty.Codecs.Http2.Tests/HpackTest.cs
@@ -20,7 +20,7 @@ public static IEnumerable<object[]> GetJsonFiles()
         }
 
         [Theory]
-        [MemberData(nameof(GetJsonFiles))]
+        [MemberData(nameof(GetJsonFiles), DisableDiscoveryEnumeration = true)]
         public void Test(FileInfo file)
         {
             using (var fs = file.Open(FileMode.Open))
diff --git a/test/DotNetty.Codecs.Protobuf.Tests/RoundTripTests.cs b/test/DotNetty.Codecs.Protobuf.Tests/RoundTripTests.cs
index 75c02b8b2..f02dccc90 100644
--- a/test/DotNetty.Codecs.Protobuf.Tests/RoundTripTests.cs
+++ b/test/DotNetty.Codecs.Protobuf.Tests/RoundTripTests.cs
@@ -187,7 +187,7 @@ public static IEnumerable<object[]> GetAddressBookCases()
         }
 
         [Theory]
-        [MemberData(nameof(GetAddressBookCases))]
+        [MemberData(nameof(GetAddressBookCases), DisableDiscoveryEnumeration = true)]
         public void Run1(AddressBook addressBook, bool isCompositeBuffer)
         {
             var channel = new EmbeddedChannel(
diff --git a/test/DotNetty.Handlers.Tests/SniHandlerTest.cs b/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
index 605dd4c71..695d3cfc7 100644
--- a/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/SniHandlerTest.cs
@@ -66,7 +66,7 @@ from targetHost in SettingMap.Keys
 
 
         [Theory]
-        [MemberData(nameof(GetTlsReadTestData))]
+        [MemberData(nameof(GetTlsReadTestData), DisableDiscoveryEnumeration = true)]
         public async Task TlsRead(int[] frameLengths, bool isClient, IWriteStrategy writeStrategy, SslProtocols protocol, string targetHost)
         {
             this.Output.WriteLine($"frameLengths: {string.Join(", ", frameLengths)}");
diff --git a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
index 907ba25b3..14d4ff9b3 100644
--- a/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
+++ b/test/DotNetty.Handlers.Tests/TlsHandlerTest.cs
@@ -114,8 +114,8 @@ from protocol in protocols
         }
 
         [Theory]
-        [MemberData(nameof(GetTlsReadTestData))]
-        [MemberData(nameof(GetTlsReadTestProtocol))]
+        [MemberData(nameof(GetTlsReadTestData), DisableDiscoveryEnumeration = true)]
+        [MemberData(nameof(GetTlsReadTestProtocol), DisableDiscoveryEnumeration = true)]
         public async Task TlsRead(int[] frameLengths, bool isClient, IWriteStrategy writeStrategy, SslProtocols serverProtocol, SslProtocols clientProtocol)
         {
             this.Output.WriteLine($"frameLengths: {string.Join(", ", frameLengths)}");
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/AbstractSocketShutdownOutputByPeerTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/AbstractSocketShutdownOutputByPeerTest.cs
index b77e117ac..b1ea5d775 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/AbstractSocketShutdownOutputByPeerTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/AbstractSocketShutdownOutputByPeerTest.cs
@@ -21,7 +21,7 @@ public AbstractSocketShutdownOutputByPeerTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestShutdownOutput(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -72,7 +72,7 @@ public void TestShutdownOutput(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestShutdownOutputWithoutOption(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/CompositeBufferGatheringWriteTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/CompositeBufferGatheringWriteTest.cs
index 4ab49055a..5b21522c1 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/CompositeBufferGatheringWriteTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/CompositeBufferGatheringWriteTest.cs
@@ -21,7 +21,7 @@ public CompositeBufferGatheringWriteTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSingleCompositeBufferWrite(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -32,7 +32,7 @@ public Task TestSingleCompositeBufferWrite(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSingleCompositeBufferWrite_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -43,7 +43,7 @@ public Task TestSingleCompositeBufferWrite_LibuvClient(IByteBufferAllocator allo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSingleCompositeBufferWrite_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -54,7 +54,7 @@ public Task TestSingleCompositeBufferWrite_LibuvServer_SocketClient(IByteBufferA
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSingleCompositeBufferWrite_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -187,7 +187,7 @@ protected static void CompositeBufferPartialWriteDoesNotCorruptDataInitServerCon
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCompositeBufferPartialWriteDoesNotCorruptData(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -198,7 +198,7 @@ public Task TestCompositeBufferPartialWriteDoesNotCorruptData(IByteBufferAllocat
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCompositeBufferPartialWriteDoesNotCorruptData_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -209,7 +209,7 @@ public Task TestCompositeBufferPartialWriteDoesNotCorruptData_LibuvClient(IByteB
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCompositeBufferPartialWriteDoesNotCorruptData_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -220,7 +220,7 @@ public Task TestCompositeBufferPartialWriteDoesNotCorruptData_LibuvServer_Socket
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCompositeBufferPartialWriteDoesNotCorruptData_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketAutoReadTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketAutoReadTest.cs
index 08baf2c90..648048c02 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketAutoReadTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketAutoReadTest.cs
@@ -18,7 +18,7 @@ public SocketAutoReadTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffDuringReadOnlyReadsOneTime(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -29,7 +29,7 @@ public Task TestAutoReadOffDuringReadOnlyReadsOneTime(IByteBufferAllocator alloc
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffDuringReadOnlyReadsOneTime_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -40,7 +40,7 @@ public Task TestAutoReadOffDuringReadOnlyReadsOneTime_LibuvClient(IByteBufferAll
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffDuringReadOnlyReadsOneTime_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -51,7 +51,7 @@ public Task TestAutoReadOffDuringReadOnlyReadsOneTime_LibuvServer_SocketClient(I
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffDuringReadOnlyReadsOneTime_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketBufReleaseTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketBufReleaseTest.cs
index daac8ad94..449d47709 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketBufReleaseTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketBufReleaseTest.cs
@@ -17,7 +17,7 @@ public SocketBufReleaseTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestBufRelease(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -28,7 +28,7 @@ public Task TestBufRelease(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestBufRelease_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -39,7 +39,7 @@ public Task TestBufRelease_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestBufRelease_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -50,7 +50,7 @@ public Task TestBufRelease_LibuvServer_SocketClient(IByteBufferAllocator allocat
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestBufRelease_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketCancelWriteTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketCancelWriteTest.cs
index 5500b0e40..87c28dfac 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketCancelWriteTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketCancelWriteTest.cs
@@ -21,7 +21,7 @@ public SocketCancelWriteTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCancelWrite(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -32,7 +32,7 @@ public Task TestCancelWrite(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCancelWrite_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -43,7 +43,7 @@ public Task TestCancelWrite_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCancelWrite_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -54,7 +54,7 @@ public Task TestCancelWrite_LibuvServer_SocketClient(IByteBufferAllocator alloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestCancelWrite_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketConditionalWritabilityTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketConditionalWritabilityTest.cs
index 30d7dea5a..68f4fb657 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketConditionalWritabilityTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketConditionalWritabilityTest.cs
@@ -23,7 +23,7 @@ public SocketConditionalWritabilityTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestConditionalWritability(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -34,7 +34,7 @@ public Task TestConditionalWritability(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestConditionalWritability_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -45,7 +45,7 @@ public Task TestConditionalWritability_LibuvClient(IByteBufferAllocator allocato
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestConditionalWritability_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -56,7 +56,7 @@ public Task TestConditionalWritability_LibuvServer_SocketClient(IByteBufferAlloc
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestConditionalWritability_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketConnectTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketConnectTest.cs
index 25639639b..aa49470ed 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketConnectTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketConnectTest.cs
@@ -29,7 +29,7 @@ public SocketConnectTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestLocalAddressAfterConnect(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -40,7 +40,7 @@ public Task TestLocalAddressAfterConnect(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestLocalAddressAfterConnect_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -51,7 +51,7 @@ public Task TestLocalAddressAfterConnect_LibuvClient(IByteBufferAllocator alloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestLocalAddressAfterConnect_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -62,7 +62,7 @@ public Task TestLocalAddressAfterConnect_LibuvServer_SocketClient(IByteBufferAll
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestLocalAddressAfterConnect_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -122,7 +122,7 @@ public override void ChannelActive(IChannelHandlerContext ctx)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestChannelEventsFiredWhenClosedDirectly(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -133,7 +133,7 @@ public Task TestChannelEventsFiredWhenClosedDirectly(IByteBufferAllocator alloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestChannelEventsFiredWhenClosedDirectly_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -144,7 +144,7 @@ public Task TestChannelEventsFiredWhenClosedDirectly_LibuvClient(IByteBufferAllo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestChannelEventsFiredWhenClosedDirectly_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -155,7 +155,7 @@ public Task TestChannelEventsFiredWhenClosedDirectly_LibuvServer_SocketClient(IB
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestChannelEventsFiredWhenClosedDirectly_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketDataReadInitialStateTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketDataReadInitialStateTest.cs
index 50aeeebc1..d3a15d4e4 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketDataReadInitialStateTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketDataReadInitialStateTest.cs
@@ -18,7 +18,7 @@ public SocketDataReadInitialStateTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffNoDataReadUntilReadCalled(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -29,7 +29,7 @@ public Task TestAutoReadOffNoDataReadUntilReadCalled(IByteBufferAllocator alloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffNoDataReadUntilReadCalled_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -40,7 +40,7 @@ public Task TestAutoReadOffNoDataReadUntilReadCalled_LibuvClient(IByteBufferAllo
         }
 
         [Theory(Skip = "TODO 暂时忽略，单独运行可通过测试")]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffNoDataReadUntilReadCalled_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -51,7 +51,7 @@ public Task TestAutoReadOffNoDataReadUntilReadCalled_LibuvServer_SocketClient(IB
         }
 
         [Theory(Skip = "TODO 暂时忽略，单独运行可通过测试")]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOffNoDataReadUntilReadCalled_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -151,7 +151,7 @@ public override void ChannelRead(IChannelHandlerContext ctx, object msg)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOnDataReadImmediately(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -162,7 +162,7 @@ public Task TestAutoReadOnDataReadImmediately(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOnDataReadImmediately_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -173,7 +173,7 @@ public Task TestAutoReadOnDataReadImmediately_LibuvClient(IByteBufferAllocator a
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOnDataReadImmediately_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -184,7 +184,7 @@ public Task TestAutoReadOnDataReadImmediately_LibuvServer_SocketClient(IByteBuff
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestAutoReadOnDataReadImmediately_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketEchoTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketEchoTest.cs
index 52d81df8b..2004beb3e 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketEchoTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketEchoTest.cs
@@ -32,7 +32,7 @@ public void Dispose()
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEcho(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -43,7 +43,7 @@ public Task TestSimpleEcho(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEcho_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -54,7 +54,7 @@ public Task TestSimpleEcho_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEcho_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -65,7 +65,7 @@ public Task TestSimpleEcho_LibuvServer_SocketClient(IByteBufferAllocator allocat
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEcho_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -91,7 +91,7 @@ private async Task TestSimpleEcho0(ServerBootstrap sb, Bootstrap cb)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -102,7 +102,7 @@ public Task TestSimpleEchoNotAutoRead(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -113,7 +113,7 @@ public Task TestSimpleEchoNotAutoRead_LibuvClient(IByteBufferAllocator allocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -124,7 +124,7 @@ public Task TestSimpleEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferAlloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -150,7 +150,7 @@ private async Task TestSimpleEchoNotAutoRead0(ServerBootstrap sb, Bootstrap cb)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutor(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -161,7 +161,7 @@ public Task TestSimpleEchoWithAdditionalExecutor(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutor_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -172,7 +172,7 @@ public Task TestSimpleEchoWithAdditionalExecutor_LibuvClient(IByteBufferAllocato
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutor_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -183,7 +183,7 @@ public Task TestSimpleEchoWithAdditionalExecutor_LibuvServer_SocketClient(IByteB
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutor_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -209,7 +209,7 @@ private async Task TestSimpleEchoWithAdditionalExecutor0(ServerBootstrap sb, Boo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -220,7 +220,7 @@ public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead(IByteBufferAllocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -231,7 +231,7 @@ public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead_LibuvClient(IByteBuf
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -242,7 +242,7 @@ public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead_LibuvServer_SocketCl
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -268,7 +268,7 @@ private async Task TestSimpleEchoWithAdditionalExecutorNotAutoRead0(ServerBootst
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromise(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -279,7 +279,7 @@ public Task TestSimpleEchoWithVoidPromise(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromise_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -290,7 +290,7 @@ public Task TestSimpleEchoWithVoidPromise_LibuvClient(IByteBufferAllocator alloc
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromise_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -301,7 +301,7 @@ public Task TestSimpleEchoWithVoidPromise_LibuvServer_SocketClient(IByteBufferAl
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromise_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -327,7 +327,7 @@ private async Task TestSimpleEchoWithVoidPromise0(ServerBootstrap sb, Bootstrap
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromiseNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -338,7 +338,7 @@ public Task TestSimpleEchoWithVoidPromiseNotAutoRead(IByteBufferAllocator alloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromiseNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -349,7 +349,7 @@ public Task TestSimpleEchoWithVoidPromiseNotAutoRead_LibuvClient(IByteBufferAllo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromiseNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -360,7 +360,7 @@ public Task TestSimpleEchoWithVoidPromiseNotAutoRead_LibuvServer_SocketClient(IB
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithVoidPromiseNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -386,7 +386,7 @@ private async Task TestSimpleEchoWithVoidPromiseNotAutoRead0(ServerBootstrap sb,
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -397,7 +397,7 @@ public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise(IByteBufferAlloca
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -408,7 +408,7 @@ public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise_LibuvClient(IByte
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -419,7 +419,7 @@ public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise_LibuvServer_Socke
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestSimpleEchoWithAdditionalExecutorAndVoidPromise_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketExceptionHandlingTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketExceptionHandlingTest.cs
index 999240e88..683edc46f 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketExceptionHandlingTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketExceptionHandlingTest.cs
@@ -28,7 +28,7 @@ public SocketExceptionHandlingTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -39,7 +39,7 @@ public Task TestReadPendingIsResetAfterEachRead(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -50,7 +50,7 @@ public Task TestReadPendingIsResetAfterEachRead_LibuvClient(IByteBufferAllocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -61,7 +61,7 @@ public Task TestReadPendingIsResetAfterEachRead_LibuvServer_SocketClient(IByteBu
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketFixedLengthEchoTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketFixedLengthEchoTest.cs
index a3e59ae78..0e5df35f2 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketFixedLengthEchoTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketFixedLengthEchoTest.cs
@@ -31,7 +31,7 @@ public SocketFixedLengthEchoTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEcho(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -42,7 +42,7 @@ public Task TestFixedLengthEcho(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEcho_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -53,7 +53,7 @@ public Task TestFixedLengthEcho_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEcho_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -64,7 +64,7 @@ public Task TestFixedLengthEcho_LibuvServer_SocketClient(IByteBufferAllocator al
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEcho_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -90,7 +90,7 @@ private async Task TestFixedLengthEcho0(ServerBootstrap sb, Bootstrap cb)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEchoNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -101,7 +101,7 @@ public Task TestFixedLengthEchoNotAutoRead(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEchoNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -112,7 +112,7 @@ public Task TestFixedLengthEchoNotAutoRead_LibuvClient(IByteBufferAllocator allo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -123,7 +123,7 @@ public Task TestFixedLengthEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferA
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestFixedLengthEchoNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketGatheringWriteTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketGatheringWriteTest.cs
index 44c129103..683e0d968 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketGatheringWriteTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketGatheringWriteTest.cs
@@ -34,7 +34,7 @@ public void Dispose()
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWrite(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -45,7 +45,7 @@ public Task TestGatheringWrite(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWrite_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -56,7 +56,7 @@ public Task TestGatheringWrite_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWrite_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -67,7 +67,7 @@ public Task TestGatheringWrite_LibuvServer_SocketClient(IByteBufferAllocator all
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWrite_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -93,7 +93,7 @@ private async Task TestGatheringWrite0(ServerBootstrap sb, Bootstrap cb)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -104,7 +104,7 @@ public Task TestGatheringWriteNotAutoRead(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -115,7 +115,7 @@ public Task TestGatheringWriteNotAutoRead_LibuvClient(IByteBufferAllocator alloc
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -126,7 +126,7 @@ public Task TestGatheringWriteNotAutoRead_LibuvServer_SocketClient(IByteBufferAl
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -152,7 +152,7 @@ private async Task TestGatheringWriteNotAutoRead0(ServerBootstrap sb, Bootstrap
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithComposite(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -163,7 +163,7 @@ public Task TestGatheringWriteWithComposite(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithComposite_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -174,7 +174,7 @@ public Task TestGatheringWriteWithComposite_LibuvClient(IByteBufferAllocator all
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithComposite_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -185,7 +185,7 @@ public Task TestGatheringWriteWithComposite_LibuvServer_SocketClient(IByteBuffer
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithComposite_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -211,7 +211,7 @@ private async Task TestGatheringWriteWithComposite0(ServerBootstrap sb, Bootstra
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithCompositeNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -222,7 +222,7 @@ public Task TestGatheringWriteWithCompositeNotAutoRead(IByteBufferAllocator allo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithCompositeNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -233,7 +233,7 @@ public Task TestGatheringWriteWithCompositeNotAutoRead_LibuvClient(IByteBufferAl
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithCompositeNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -244,7 +244,7 @@ public Task TestGatheringWriteWithCompositeNotAutoRead_LibuvServer_SocketClient(
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteWithCompositeNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -271,7 +271,7 @@ private async Task TestGatheringWriteWithCompositeNotAutoRead0(ServerBootstrap s
 
         // Test for https://github.com/netty/netty/issues/2647
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteBig(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -282,7 +282,7 @@ public Task TestGatheringWriteBig(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteBig_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -293,7 +293,7 @@ public Task TestGatheringWriteBig_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteBig_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -304,7 +304,7 @@ public Task TestGatheringWriteBig_LibuvServer_SocketClient(IByteBufferAllocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestGatheringWriteBig_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketHalfClosedTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketHalfClosedTest.cs
index 38281c1ed..cf5dc1079 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketHalfClosedTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketHalfClosedTest.cs
@@ -20,7 +20,7 @@ public SocketHalfClosedTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestHalfClosureOnlyOneEventWhenAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -113,7 +113,7 @@ public override void ExceptionCaught(IChannelHandlerContext ctx, Exception cause
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestAllDataReadAfterHalfClosure(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -276,7 +276,7 @@ public override void ExceptionCaught(IChannelHandlerContext ctx, Exception cause
         }
 
         //[Theory]
-        //[MemberData(nameof(GetAllocators))]
+        //[MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         [Fact(Skip = "TestAutoCloseFalseDoesShutdownOutput")]
         public void TestAutoCloseFalseDoesShutdownOutput(/*IByteBufferAllocator allocator*/)
         {
@@ -509,7 +509,7 @@ private void CheckPrematureClose()
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestAllDataReadClosure(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -520,7 +520,7 @@ public void TestAllDataReadClosure(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestAllDataReadClosure_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -531,7 +531,7 @@ public void TestAllDataReadClosure_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestAllDataReadClosure_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -542,7 +542,7 @@ public void TestAllDataReadClosure_LibuvServer_SocketClient(IByteBufferAllocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void TestAllDataReadClosure_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketReadPendingTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketReadPendingTest.cs
index fe9d6d02b..3bbda012a 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketReadPendingTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketReadPendingTest.cs
@@ -18,7 +18,7 @@ public SocketReadPendingTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -29,7 +29,7 @@ public Task TestReadPendingIsResetAfterEachRead(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -40,7 +40,7 @@ public Task TestReadPendingIsResetAfterEachRead_LibuvClient(IByteBufferAllocator
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -51,7 +51,7 @@ public Task TestReadPendingIsResetAfterEachRead_LibuvServer_SocketClient(IByteBu
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestReadPendingIsResetAfterEachRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketRstTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketRstTest.cs
index 366856a13..8a5c1f646 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketRstTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketRstTest.cs
@@ -29,7 +29,7 @@ public SocketRstTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestSoLingerZeroCausesOnlyRstOnClose(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -50,7 +50,7 @@ public async Task TestSoLingerZeroCausesOnlyRstOnClose(IByteBufferAllocator allo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestSoLingerZeroCausesOnlyRstOnClose_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -71,7 +71,7 @@ public async Task TestSoLingerZeroCausesOnlyRstOnClose_LibuvClient(IByteBufferAl
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestSoLingerZeroCausesOnlyRstOnClose_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -92,7 +92,7 @@ public async Task TestSoLingerZeroCausesOnlyRstOnClose_LibuvServer_SocketClient(
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestSoLingerZeroCausesOnlyRstOnClose_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -153,7 +153,7 @@ private async Task TestSoLingerZeroCausesOnlyRstOnClose0(ServerBootstrap sb, Boo
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestNoRstIfSoLingerOnClose(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -174,7 +174,7 @@ public async Task TestNoRstIfSoLingerOnClose(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestNoRstIfSoLingerOnClose_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -195,7 +195,7 @@ public async Task TestNoRstIfSoLingerOnClose_LibuvClient(IByteBufferAllocator al
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestNoRstIfSoLingerOnClose_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -216,7 +216,7 @@ public async Task TestNoRstIfSoLingerOnClose_LibuvServer_SocketClient(IByteBuffe
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public async Task TestNoRstIfSoLingerOnClose_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/SocketStringEchoTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/SocketStringEchoTest.cs
index 5da9d407a..4dc64409d 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/SocketStringEchoTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/SocketStringEchoTest.cs
@@ -43,7 +43,7 @@ public SocketStringEchoTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEcho(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -54,7 +54,7 @@ public Task TestStringEcho(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEcho_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -65,7 +65,7 @@ public Task TestStringEcho_LibuvClient(IByteBufferAllocator allocator)
         }
 
         [Theory()]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEcho_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -76,7 +76,7 @@ public Task TestStringEcho_LibuvServer_SocketClient(IByteBufferAllocator allocat
         }
 
         [Theory()]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEcho_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -103,7 +103,7 @@ private async Task TestStringEcho0(ServerBootstrap sb, Bootstrap cb)
 
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEchoNotAutoRead(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -114,7 +114,7 @@ public Task TestStringEchoNotAutoRead(IByteBufferAllocator allocator)
         }
 
         [Theory()]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEchoNotAutoRead_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = DefaultServerBootstrapFactory.Instance.NewInstance();
@@ -125,7 +125,7 @@ public Task TestStringEchoNotAutoRead_LibuvClient(IByteBufferAllocator allocator
         }
 
         [Theory()]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
@@ -136,7 +136,7 @@ public Task TestStringEchoNotAutoRead_LibuvServer_SocketClient(IByteBufferAlloca
         }
 
         [Theory()]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public Task TestStringEchoNotAutoRead_LibuvServer_LibuvClient(IByteBufferAllocator allocator)
         {
             var sb = LibuvServerBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Suite.Tests/Transport/Socket/WriteBeforeRegisteredTest.cs b/test/DotNetty.Suite.Tests/Transport/Socket/WriteBeforeRegisteredTest.cs
index fced79abb..57c894695 100644
--- a/test/DotNetty.Suite.Tests/Transport/Socket/WriteBeforeRegisteredTest.cs
+++ b/test/DotNetty.Suite.Tests/Transport/Socket/WriteBeforeRegisteredTest.cs
@@ -16,7 +16,7 @@ public WriteBeforeRegisteredTest(ITestOutputHelper output)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void WriteBeforeConnect(IByteBufferAllocator allocator)
         {
             var cb = DefaultClientBootstrapFactory.Instance.NewInstance();
@@ -26,7 +26,7 @@ public void WriteBeforeConnect(IByteBufferAllocator allocator)
         }
 
         [Theory]
-        [MemberData(nameof(GetAllocators))]
+        [MemberData(nameof(GetAllocators), DisableDiscoveryEnumeration = true)]
         public void LibuvWriteBeforeConnect(IByteBufferAllocator allocator)
         {
             var cb = LibuvClientBootstrapFactory.Instance.NewInstance();
diff --git a/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelMulticastTest.cs b/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelMulticastTest.cs
index c0905417b..71337e90e 100644
--- a/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelMulticastTest.cs
+++ b/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelMulticastTest.cs
@@ -94,7 +94,7 @@ public static IEnumerable<object[]> GetData()
         }
 
         [Theory]
-        [MemberData(nameof(GetData))]
+        [MemberData(nameof(GetData), DisableDiscoveryEnumeration = true)]
         public void Multicast(AddressFamily addressFamily, IByteBufferAllocator allocator)
         {
             if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
diff --git a/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelUnicastTest.cs b/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelUnicastTest.cs
index 8e9a93cd1..d34fe9946 100644
--- a/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelUnicastTest.cs
+++ b/test/DotNetty.Transport.Tests/Channel/Sockets/SocketDatagramChannelUnicastTest.cs
@@ -144,7 +144,7 @@ public static IEnumerable<object[]> GetData()
         }
 
         [Theory]
-        [MemberData(nameof(GetData))]
+        [MemberData(nameof(GetData), DisableDiscoveryEnumeration = true)]
         public void SimpleSend(IByteBuffer source, bool bindClient, IByteBufferAllocator allocator, AddressFamily addressFamily, byte[] expectedData, int count)
         {
             if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))