Fix Proxying when StartAdminInterface=true (#778)

* ProxyHelper fixes

* .

* more reformat

* .

src/WireMock.Net/Util/BytesEncodingUtils.cs

@@ -1,230 +1,230 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+/// <summary>
+/// Based on:
+/// http://utf8checker.codeplex.com
+/// https://github.com/0x53A/Mvvm/blob/master/src/Mvvm/src/Utf8Checker.cs
+///
+/// References:
+/// http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335
+/// http://www.cl.cam.ac.uk/~mgk25/ucs/ISO-10646-UTF-8.html
+/// http://www.unicode.org/versions/corrigendum1.html
+/// http://www.ietf.org/rfc/rfc2279.txt
+/// </summary>
+public static class BytesEncodingUtils
 {
     /// <summary>
-    /// Based on:
-    /// http://utf8checker.codeplex.com
-    /// https://github.com/0x53A/Mvvm/blob/master/src/Mvvm/src/Utf8Checker.cs
-    ///
-    /// References:
-    /// http://anubis.dkuug.dk/JTC1/SC2/WG2/docs/n1335
-    /// http://www.cl.cam.ac.uk/~mgk25/ucs/ISO-10646-UTF-8.html
-    /// http://www.unicode.org/versions/corrigendum1.html
-    /// http://www.ietf.org/rfc/rfc2279.txt
+    /// Tries the get the Encoding from an array of bytes.
     /// </summary>
-    public static class BytesEncodingUtils
+    /// <param name="bytes">The bytes.</param>
+    /// <param name="encoding">The output encoding.</param>
+    public static bool TryGetEncoding(byte[] bytes, [NotNullWhen(true)] out Encoding? encoding)
     {
-        /// <summary>
-        /// Tries the get the Encoding from an array of bytes.
-        /// </summary>
-        /// <param name="bytes">The bytes.</param>
-        /// <param name="encoding">The output encoding.</param>
-        public static bool TryGetEncoding(byte[] bytes, out Encoding encoding)
+        encoding = null;
+        if (bytes.All(b => b < 80))
         {
-            encoding = null;
-            if (bytes.All(b => b < 80))
-            {
-                encoding = Encoding.ASCII;
-                return true;
-            }
-
-            if (StartsWith(bytes, new byte[] { 0xff, 0xfe, 0x00, 0x00 }))
-            {
-                encoding = Encoding.UTF32;
-                return true;
-            }
-
-            if (StartsWith(bytes, new byte[] { 0xfe, 0xff }))
-            {
-                encoding = Encoding.BigEndianUnicode;
-                return true;
-            }
-
-            if (StartsWith(bytes, new byte[] { 0xff, 0xfe }))
-            {
-                encoding = Encoding.Unicode;
-                return true;
-            }
-
-            if (StartsWith(bytes, new byte[] { 0xef, 0xbb, 0xbf }))
-            {
-                encoding = Encoding.UTF8;
-                return true;
-            }
-
-            if (IsUtf8(bytes, bytes.Length))
-            {
-                encoding = new UTF8Encoding(false);
-                return true;
-            }
-
-            return false;
-        }
-
-        private static bool StartsWith(IEnumerable<byte> data, IReadOnlyCollection<byte> other)
-        {
-            byte[] arraySelf = data.Take(other.Count).ToArray();
-            return other.SequenceEqual(arraySelf);
-        }
-
-        private static bool IsUtf8(IReadOnlyList<byte> buffer, int length)
-        {
-            int position = 0;
-            int bytes = 0;
-            while (position < length)
-            {
-                if (!IsValid(buffer, position, length, ref bytes))
-                {
-                    return false;
-                }
-                position += bytes;
-            }
+            encoding = Encoding.ASCII;
             return true;
         }
 
-#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
-        private static bool IsValid(IReadOnlyList<byte> buffer, int position, int length, ref int bytes)
+        if (StartsWith(bytes, new byte[] { 0xff, 0xfe, 0x00, 0x00 }))
         {
-            if (length > buffer.Count)
-            {
-                throw new ArgumentException("Invalid length");
-            }
+            encoding = Encoding.UTF32;
+            return true;
+        }
 
-            if (position > length - 1)
+        if (StartsWith(bytes, new byte[] { 0xfe, 0xff }))
+        {
+            encoding = Encoding.BigEndianUnicode;
+            return true;
+        }
+
+        if (StartsWith(bytes, new byte[] { 0xff, 0xfe }))
+        {
+            encoding = Encoding.Unicode;
+            return true;
+        }
+
+        if (StartsWith(bytes, new byte[] { 0xef, 0xbb, 0xbf }))
+        {
+            encoding = Encoding.UTF8;
+            return true;
+        }
+
+        if (IsUtf8(bytes, bytes.Length))
+        {
+            encoding = new UTF8Encoding(false);
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool StartsWith(IEnumerable<byte> data, IReadOnlyCollection<byte> other)
+    {
+        byte[] arraySelf = data.Take(other.Count).ToArray();
+        return other.SequenceEqual(arraySelf);
+    }
+
+    private static bool IsUtf8(IReadOnlyList<byte> buffer, int length)
+    {
+        int position = 0;
+        int bytes = 0;
+        while (position < length)
+        {
+            if (!IsValid(buffer, position, length, ref bytes))
+            {
+                return false;
+            }
+            position += bytes;
+        }
+        return true;
+    }
+
+#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
+    private static bool IsValid(IReadOnlyList<byte> buffer, int position, int length, ref int bytes)
+    {
+        if (length > buffer.Count)
+        {
+            throw new ArgumentException("Invalid length");
+        }
+
+        if (position > length - 1)
+        {
+            bytes = 0;
+            return true;
+        }
+
+        byte ch = buffer[position];
+        if (ch <= 0x7F)
+        {
+            bytes = 1;
+            return true;
+        }
+
+        if (ch >= 0xc2 && ch <= 0xdf)
+        {
+            if (position >= length - 2)
             {
                 bytes = 0;
-                return true;
+                return false;
             }
 
-            byte ch = buffer[position];
-            if (ch <= 0x7F)
+            if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf)
             {
-                bytes = 1;
-                return true;
+                bytes = 0;
+                return false;
             }
 
-            if (ch >= 0xc2 && ch <= 0xdf)
-            {
-                if (position >= length - 2)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 2;
-                return true;
-            }
-
-            if (ch == 0xe0)
-            {
-                if (position >= length - 3)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0xa0 || buffer[position + 1] > 0xbf ||
-                    buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 3;
-                return true;
-            }
-
-            if (ch >= 0xe1 && ch <= 0xef)
-            {
-                if (position >= length - 3)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf ||
-                    buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 3;
-                return true;
-            }
-
-            if (ch == 0xf0)
-            {
-                if (position >= length - 4)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0x90 || buffer[position + 1] > 0xbf ||
-                    buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
-                    buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 4;
-                return true;
-            }
-
-            if (ch == 0xf4)
-            {
-                if (position >= length - 4)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0x8f ||
-                    buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
-                    buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 4;
-                return true;
-            }
-
-            if (ch >= 0xf1 && ch <= 0xf3)
-            {
-                if (position >= length - 4)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf ||
-                    buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
-                    buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
-                {
-                    bytes = 0;
-                    return false;
-                }
-
-                bytes = 4;
-                return true;
-            }
-
-            return false;
+            bytes = 2;
+            return true;
         }
+
+        if (ch == 0xe0)
+        {
+            if (position >= length - 3)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            if (buffer[position + 1] < 0xa0 || buffer[position + 1] > 0xbf ||
+                buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            bytes = 3;
+            return true;
+        }
+
+        if (ch >= 0xe1 && ch <= 0xef)
+        {
+            if (position >= length - 3)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf ||
+                buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            bytes = 3;
+            return true;
+        }
+
+        if (ch == 0xf0)
+        {
+            if (position >= length - 4)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            if (buffer[position + 1] < 0x90 || buffer[position + 1] > 0xbf ||
+                buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
+                buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            bytes = 4;
+            return true;
+        }
+
+        if (ch == 0xf4)
+        {
+            if (position >= length - 4)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0x8f ||
+                buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
+                buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            bytes = 4;
+            return true;
+        }
+
+        if (ch >= 0xf1 && ch <= 0xf3)
+        {
+            if (position >= length - 4)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            if (buffer[position + 1] < 0x80 || buffer[position + 1] > 0xbf ||
+                buffer[position + 2] < 0x80 || buffer[position + 2] > 0xbf ||
+                buffer[position + 3] < 0x80 || buffer[position + 3] > 0xbf)
+            {
+                bytes = 0;
+                return false;
+            }
+
+            bytes = 4;
+            return true;
+        }
+
+        return false;
     }
-#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
-}
+}
+#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high

src/WireMock.Net/Util/CompressionUtils.cs

@@ -1,49 +1,39 @@
-using System;
+using System;
 using System.IO;
 using System.IO.Compression;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class CompressionUtils
 {
-    internal static class CompressionUtils
+    public static byte[] Compress(string contentEncoding, byte[] data)
     {
-        public static byte[] Compress(string contentEncoding, byte[] data)
-        {
-            using (var compressedStream = new MemoryStream())
-            using (var zipStream = Create(contentEncoding, compressedStream, CompressionMode.Compress))
-            {
-                zipStream.Write(data, 0, data.Length);
+        using var compressedStream = new MemoryStream();
+        using var zipStream = Create(contentEncoding, compressedStream, CompressionMode.Compress);
+        zipStream.Write(data, 0, data.Length);
 
 #if !NETSTANDARD1_3
-                zipStream.Close();
+        zipStream.Close();
 #endif
-                return compressedStream.ToArray();
-            }
-        }
+        return compressedStream.ToArray();
+    }
 
-        public static byte[] Decompress(string contentEncoding, byte[] data)
+    public static byte[] Decompress(string contentEncoding, byte[] data)
+    {
+        using var compressedStream = new MemoryStream(data);
+        using var zipStream = Create(contentEncoding, compressedStream, CompressionMode.Decompress);
+        using var resultStream = new MemoryStream();
+        zipStream.CopyTo(resultStream);
+        return resultStream.ToArray();
+    }
+
+    private static Stream Create(string contentEncoding, Stream stream, CompressionMode mode)
+    {
+        return contentEncoding switch
         {
-            using (var compressedStream = new MemoryStream(data))
-            using (var zipStream = Create(contentEncoding, compressedStream, CompressionMode.Decompress))
-            using (var resultStream = new MemoryStream())
-            {
-                zipStream.CopyTo(resultStream);
-                return resultStream.ToArray();
-            }
-        }
-
-        private static Stream Create(string contentEncoding, Stream stream, CompressionMode mode)
-        {
-            switch (contentEncoding)
-            {
-                case "gzip":
-                    return new GZipStream(stream, mode);
-
-                case "deflate":
-                    return new DeflateStream(stream, mode);
-
-                default:
-                    throw new NotSupportedException($"ContentEncoding '{contentEncoding}' is not supported.");
-            }
-        }
+            "gzip" => new GZipStream(stream, mode),
+            "deflate" => new DeflateStream(stream, mode),
+            _ => throw new NotSupportedException($"ContentEncoding '{contentEncoding}' is not supported.")
+        };
     }
 }

src/WireMock.Net/Util/DictionaryExtensions.cs

@@ -1,32 +1,30 @@
-using System;
+using System;
 using System.Collections.Generic;
-using JetBrains.Annotations;
 using Stef.Validation;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+/// <summary>
+/// Some IDictionary Extensions
+/// </summary>
+public static class DictionaryExtensions
 {
     /// <summary>
-    /// Some IDictionary Extensions
+    /// Loops the dictionary and executes the specified action.
     /// </summary>
-    public static class DictionaryExtensions
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TValue">The type of the value.</typeparam>
+    /// <param name="dictionary">The dictionary to loop (can be null).</param>
+    /// <param name="action">The action.</param>
+    public static void Loop<TKey, TValue>(this IDictionary<TKey, TValue>? dictionary, Action<TKey, TValue> action)
     {
-        /// <summary>
-        /// Loops the dictionary and executes the specified action.
-        /// </summary>
-        /// <typeparam name="TKey">The type of the key.</typeparam>
-        /// <typeparam name="TValue">The type of the value.</typeparam>
-        /// <param name="dictionary">The dictionary to loop (can be null).</param>
-        /// <param name="action">The action.</param>
-        public static void Loop<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, [NotNull] Action<TKey, TValue> action)
-        {
-            Guard.NotNull(action, nameof(action));
+        Guard.NotNull(action);
 
-            if (dictionary != null)
+        if (dictionary != null)
+        {
+            foreach (var entry in dictionary)
             {
-                foreach (var entry in dictionary)
-                {
-                    action(entry.Key, entry.Value);
-                }
+                action(entry.Key, entry.Value);
             }
         }
     }

src/WireMock.Net/Util/FileHelper.cs

@@ -1,36 +1,35 @@
-using JetBrains.Annotations;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
-using WireMock.Handlers;
 using Stef.Validation;
+using WireMock.Handlers;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class FileHelper
 {
-    internal static class FileHelper
+    private const int NumberOfRetries = 3;
+    private const int DelayOnRetry = 500;
+
+    public static bool TryReadMappingFileWithRetryAndDelay(IFileSystemHandler handler, string path, [NotNullWhen(true)] out string? value)
     {
-        private const int NumberOfRetries = 3;
-        private const int DelayOnRetry = 500;
+        Guard.NotNull(handler);
+        Guard.NotNullOrEmpty(path);
 
-        public static bool TryReadMappingFileWithRetryAndDelay([NotNull] IFileSystemHandler handler, [NotNull] string path, out string value)
+        value = null;
+
+        for (int i = 1; i <= NumberOfRetries; ++i)
         {
-            Guard.NotNull(handler, nameof(handler));
-            Guard.NotNullOrEmpty(path, nameof(path));
-
-            value = null;
-
-            for (int i = 1; i <= NumberOfRetries; ++i)
+            try
             {
-                try
-                {
-                    value = handler.ReadMappingFile(path);
-                    return true;
-                }
-                catch
-                {
-                    Thread.Sleep(DelayOnRetry);
-                }
+                value = handler.ReadMappingFile(path);
+                return true;
+            }
+            catch
+            {
+                Thread.Sleep(DelayOnRetry);
             }
-
-            return false;
         }
+
+        return false;
     }
 }

src/WireMock.Net/Util/HttpStatusRangeParser.cs

@@ -1,91 +1,90 @@
-using System;
+using System;
 using System.Linq;
 using System.Net;
 using System.Text.RegularExpressions;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+/// <summary>
+/// Based on https://github.com/tmenier/Flurl/blob/129565361e135e639f1d44a35a78aea4302ac6ca/src/Flurl.Http/HttpStatusRangeParser.cs
+/// </summary>
+internal static class HttpStatusRangeParser
 {
     /// <summary>
-    /// Based on https://github.com/tmenier/Flurl/blob/129565361e135e639f1d44a35a78aea4302ac6ca/src/Flurl.Http/HttpStatusRangeParser.cs
+    /// Determines whether the specified pattern is match.
     /// </summary>
-    internal static class HttpStatusRangeParser
+    /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
+    /// <param name="httpStatusCode">The value.</param>
+    /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
+    public static bool IsMatch(string pattern, object httpStatusCode)
     {
-        /// <summary>
-        /// Determines whether the specified pattern is match.
-        /// </summary>
-        /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
-        /// <param name="httpStatusCode">The value.</param>
-        /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
-        public static bool IsMatch(string pattern, object httpStatusCode)
+        switch (httpStatusCode)
         {
-            switch (httpStatusCode)
-            {
-                case int statusCodeAsInteger:
-                    return IsMatch(pattern, statusCodeAsInteger);
+            case int statusCodeAsInteger:
+                return IsMatch(pattern, statusCodeAsInteger);
 
-                case string statusCodeAsString:
-                    return IsMatch(pattern, int.Parse(statusCodeAsString));
+            case string statusCodeAsString:
+                return IsMatch(pattern, int.Parse(statusCodeAsString));
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether the specified pattern is match.
+    /// </summary>
+    /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
+    /// <param name="httpStatusCode">The value.</param>
+    /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
+    public static bool IsMatch(string pattern, HttpStatusCode httpStatusCode)
+    {
+        return IsMatch(pattern, (int)httpStatusCode);
+    }
+
+    /// <summary>
+    /// Determines whether the specified pattern is match.
+    /// </summary>
+    /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
+    /// <param name="httpStatusCode">The value.</param>
+    /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
+    public static bool IsMatch(string? pattern, int httpStatusCode)
+    {
+        if (pattern == null)
+        {
+            return true;
+        }
+
+        foreach (var range in pattern.Split(',').Select(p => p.Trim()))
+        {
+            switch (range)
+            {
+                case "":
+                    continue;
+
+                case "*":
+                    return true; // special case - allow everything
             }
 
-            return false;
-        }
+            string[] bounds = range.Split('-');
+            int lower = 0;
+            int upper = 0;
 
-        /// <summary>
-        /// Determines whether the specified pattern is match.
-        /// </summary>
-        /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
-        /// <param name="httpStatusCode">The value.</param>
-        /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
-        public static bool IsMatch(string pattern, HttpStatusCode httpStatusCode)
-        {
-            return IsMatch(pattern, (int)httpStatusCode);
-        }
+            bool valid =
+                bounds.Length <= 2 &&
+                int.TryParse(Regex.Replace(bounds.First().Trim(), "[*xX]", "0"), out lower) &&
+                int.TryParse(Regex.Replace(bounds.Last().Trim(), "[*xX]", "9"), out upper);
 
-        /// <summary>
-        /// Determines whether the specified pattern is match.
-        /// </summary>
-        /// <param name="pattern">The pattern. (Can be null, in that case it's allowed.)</param>
-        /// <param name="httpStatusCode">The value.</param>
-        /// <exception cref="ArgumentException"><paramref name="pattern"/> is invalid.</exception>
-        public static bool IsMatch(string pattern, int httpStatusCode)
-        {
-            if (pattern == null)
+            if (!valid)
+            {
+                throw new ArgumentException($"Invalid range pattern: \"{pattern}\". Examples of allowed patterns: \"400\", \"4xx\", \"300,400-403\", \"*\".");
+            }
+
+            if (httpStatusCode >= lower && httpStatusCode <= upper)
             {
                 return true;
             }
-
-            foreach (var range in pattern.Split(',').Select(p => p.Trim()))
-            {
-                switch (range)
-                {
-                    case "":
-                        continue;
-
-                    case "*":
-                        return true; // special case - allow everything
-                }
-
-                string[] bounds = range.Split('-');
-                int lower = 0;
-                int upper = 0;
-
-                bool valid =
-                    bounds.Length <= 2 &&
-                    int.TryParse(Regex.Replace(bounds.First().Trim(), "[*xX]", "0"), out lower) &&
-                    int.TryParse(Regex.Replace(bounds.Last().Trim(), "[*xX]", "9"), out upper);
-
-                if (!valid)
-                {
-                    throw new ArgumentException($"Invalid range pattern: \"{pattern}\". Examples of allowed patterns: \"400\", \"4xx\", \"300,400-403\", \"*\".");
-                }
-
-                if (httpStatusCode >= lower && httpStatusCode <= upper)
-                {
-                    return true;
-                }
-            }
-
-            return false;
         }
+
+        return false;
     }
 }

src/WireMock.Net/Util/PortUtils.cs

@@ -1,58 +1,58 @@
-using System;
+using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Net.Sockets;
 using System.Text.RegularExpressions;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+/// <summary>
+/// Port Utility class
+/// </summary>
+public static class PortUtils
 {
+    private static readonly Regex UrlDetailsRegex = new(@"^((?<proto>\w+)://)(?<host>[^/]+?):(?<port>\d+)\/?$", RegexOptions.Compiled);
+
     /// <summary>
-    /// Port Utility class
+    /// Finds a free TCP port.
     /// </summary>
-    public static class PortUtils
+    /// <remarks>see http://stackoverflow.com/questions/138043/find-the-next-tcp-port-in-net.</remarks>
+    public static int FindFreeTcpPort()
     {
-        private static readonly Regex UrlDetailsRegex = new Regex(@"^((?<proto>\w+)://)(?<host>[^/]+?):(?<port>\d+)\/?$", RegexOptions.Compiled);
-
-        /// <summary>
-        /// Finds a free TCP port.
-        /// </summary>
-        /// <remarks>see http://stackoverflow.com/questions/138043/find-the-next-tcp-port-in-net.</remarks>
-        public static int FindFreeTcpPort()
+        TcpListener? tcpListener = null;
+        try
         {
-            TcpListener tcpListener = null;
-            try
-            {
-                tcpListener = new TcpListener(IPAddress.Loopback, 0);
-                tcpListener.Start();
+            tcpListener = new TcpListener(IPAddress.Loopback, 0);
+            tcpListener.Start();
 
-                return ((IPEndPoint)tcpListener.LocalEndpoint).Port;
-            }
-            finally
-            {
-                tcpListener?.Stop();
-            }
+            return ((IPEndPoint)tcpListener.LocalEndpoint).Port;
         }
-
-        /// <summary>
-        /// Extract the if-isHttps, protocol, host and port from a URL.
-        /// </summary>
-        public static bool TryExtract(string url, out bool isHttps, out string protocol, out string host, out int port)
+        finally
         {
-            isHttps = false;
-            protocol = null;
-            host = null;
-            port = default;
-
-            var match = UrlDetailsRegex.Match(url);
-            if (match.Success)
-            {
-                protocol = match.Groups["proto"].Value;
-                isHttps = protocol.StartsWith("https", StringComparison.OrdinalIgnoreCase);
-                host = match.Groups["host"].Value;
-
-                return int.TryParse(match.Groups["port"].Value, out port);
-            }
-
-            return false;
+            tcpListener?.Stop();
         }
     }
+
+    /// <summary>
+    /// Extract the if-isHttps, protocol, host and port from a URL.
+    /// </summary>
+    public static bool TryExtract(string url, out bool isHttps, [NotNullWhen(true)] out string? protocol, [NotNullWhen(true)] out string? host, out int port)
+    {
+        isHttps = false;
+        protocol = null;
+        host = null;
+        port = default;
+
+        var match = UrlDetailsRegex.Match(url);
+        if (match.Success)
+        {
+            protocol = match.Groups["proto"].Value;
+            isHttps = protocol.StartsWith("https", StringComparison.OrdinalIgnoreCase);
+            host = match.Groups["host"].Value;
+
+            return int.TryParse(match.Groups["port"].Value, out port);
+        }
+
+        return false;
+    }
 }

src/WireMock.Net/Util/QueryStringParser.cs

@@ -1,38 +1,37 @@
-using System;
+using System;
 using System.Net;
 using System.Collections.Generic;
 using System.Linq;
 using WireMock.Types;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+/// <summary>
+/// Based on https://stackoverflow.com/questions/659887/get-url-parameters-from-a-string-in-net
+/// </summary>
+internal static class QueryStringParser
 {
-    /// <summary>
-    /// Based on https://stackoverflow.com/questions/659887/get-url-parameters-from-a-string-in-net
-    /// </summary>
-    internal static class QueryStringParser
+    public static IDictionary<string, WireMockList<string>> Parse(string queryString)
     {
-        public static IDictionary<string, WireMockList<string>> Parse(string queryString)
+        if (string.IsNullOrEmpty(queryString))
         {
-            if (string.IsNullOrEmpty(queryString))
-            {
-                return new Dictionary<string, WireMockList<string>>();
-            }
-
-            string[] JoinParts(string[] parts)
-            {
-                if (parts.Length > 1)
-                {
-                    return parts[1].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries); // support "?key=1,2"
-                }
-
-                return new string[0];
-            }
-
-            return queryString.TrimStart('?')
-                .Split(new[] { '&', ';' }, StringSplitOptions.RemoveEmptyEntries) // Support "?key=value;key=anotherValue" and "?key=value&key=anotherValue"
-                .Select(parameter => parameter.Split(new[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries))
-                .GroupBy(parts => parts[0], JoinParts)
-                .ToDictionary(grouping => grouping.Key, grouping => new WireMockList<string>(grouping.SelectMany(x => x).Select(WebUtility.UrlDecode)));
+            return new Dictionary<string, WireMockList<string>>();
         }
+
+        string[] JoinParts(string[] parts)
+        {
+            if (parts.Length > 1)
+            {
+                return parts[1].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries); // support "?key=1,2"
+            }
+
+            return new string[0];
+        }
+
+        return queryString.TrimStart('?')
+            .Split(new[] { '&', ';' }, StringSplitOptions.RemoveEmptyEntries) // Support "?key=value;key=anotherValue" and "?key=value&key=anotherValue"
+            .Select(parameter => parameter.Split(new[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries))
+            .GroupBy(parts => parts[0], JoinParts)
+            .ToDictionary(grouping => grouping.Key, grouping => new WireMockList<string>(grouping.SelectMany(x => x).Select(WebUtility.UrlDecode)));
     }
 }

src/WireMock.Net/Util/TypeBuilderUtils.cs

@@ -14,8 +14,8 @@ internal static class TypeBuilderUtils
 {
     private static readonly ConcurrentDictionary<IDictionary<string, Type>, Type> Types = new();
 
-    private static readonly ModuleBuilder ModuleBuilder =
-        AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("WireMock.Net.Reflection"), AssemblyBuilderAccess.Run)
+    private static readonly ModuleBuilder ModuleBuilder = AssemblyBuilder
+            .DefineDynamicAssembly(new AssemblyName("WireMock.Net.Reflection"), AssemblyBuilderAccess.Run)
             .DefineDynamicModule("WireMock.Net.Reflection.Module");
 
     public static Type BuildType(IDictionary<string, Type> properties, string? name = null)

src/WireMock.Net/Util/UrlUtils.cs

@@ -1,5 +1,4 @@
-using System;
-using JetBrains.Annotations;
+using System;
 using WireMock.Models;
 using Stef.Validation;
 #if !USE_ASPNETCORE
@@ -8,34 +7,33 @@ using Microsoft.Owin;
 using Microsoft.AspNetCore.Http;
 #endif
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class UrlUtils
 {
-    internal static class UrlUtils
+    public static UrlDetails Parse(Uri uri, PathString pathBase)
     {
-        public static UrlDetails Parse([NotNull] Uri uri, PathString pathBase)
+        Guard.NotNull(uri);
+
+        if (!pathBase.HasValue)
         {
-            Guard.NotNull(uri, nameof(uri));
-
-            if (!pathBase.HasValue)
-            {
-                return new UrlDetails(uri, uri);
-            }
-
-            var builder = new UriBuilder(uri);
-            builder.Path = RemoveFirst(builder.Path, pathBase.Value);
-
-            return new UrlDetails(uri, builder.Uri);
+            return new UrlDetails(uri, uri);
         }
 
-        private static string RemoveFirst(string text, string search)
-        {
-            int pos = text.IndexOf(search, StringComparison.Ordinal);
-            if (pos < 0)
-            {
-                return text;
-            }
+        var builder = new UriBuilder(uri);
+        builder.Path = RemoveFirst(builder.Path, pathBase.Value);
 
-            return text.Substring(0, pos) + text.Substring(pos + search.Length);
-        }
+        return new UrlDetails(uri, builder.Uri);
     }
-}
+
+    private static string RemoveFirst(string text, string search)
+    {
+        int pos = text.IndexOf(search, StringComparison.Ordinal);
+        if (pos < 0)
+        {
+            return text;
+        }
+
+        return text.Substring(0, pos) + text.Substring(pos + search.Length);
+    }
+}