1.5.3

* JsonPartialMatcher - support Regex

* .

* .

* more tests

* .

* .

CHANGELOG.md

@@ -1,3 +1,12 @@
+# 1.5.3 (29 July 2022)
+- [#777](https://github.com/WireMock-Net/WireMock.Net/pull/777) - Update Scriban.Signed to version 5.5.0 [feature] contributed by [StefH](https://github.com/StefH)
+- [#776](https://github.com/WireMock-Net/WireMock.Net/issues/776) - Update Scriban.Signed to support more functions, e.g math.random [feature]
+
+# 1.5.2 (24 July 2022)
+- [#769](https://github.com/WireMock-Net/WireMock.Net/pull/769) - Bump Microsoft.AspNetCore.Server.Kestrel.Core from 2.1.3 to 2.1.7 in /examples/WireMock.Net.StandAlone.Net461 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#770](https://github.com/WireMock-Net/WireMock.Net/pull/770) - Added some more tests for JsonMatcher + refactored some code to use nullable [test] contributed by [StefH](https://github.com/StefH)
+- [#771](https://github.com/WireMock-Net/WireMock.Net/pull/771) - JsonPartialMatcher - support Regex [feature] contributed by [StefH](https://github.com/StefH)
+
 # 1.5.1 (08 July 2022)
 - [#762](https://github.com/WireMock-Net/WireMock.Net/pull/762) - Bump Newtonsoft.Json from 11.0.2 to 13.0.1 in /examples/WireMock.Net.WebApplication.NETCore2 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
 - [#763](https://github.com/WireMock-Net/WireMock.Net/pull/763) - Bump Newtonsoft.Json from 6.0.1 to 13.0.1 in /examples/WireMock.Net.Client.Net472 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)

Directory.Build.props

@@ -4,7 +4,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <VersionPrefix>1.5.1</VersionPrefix>
+        <VersionPrefix>1.5.3</VersionPrefix>
         <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
         <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

Generate-ReleaseNotes.cmd

@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes
 
-SET version=1.5.1
+SET version=1.5.3
 
 GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc duplicate --version %version% --token %GH_TOKEN%
 

PackageReleaseNotes.txt

@@ -1,9 +1,5 @@
-# 1.5.1 (08 July 2022)
-- #762 Bump Newtonsoft.Json from 11.0.2 to 13.0.1 in /examples/WireMock.Net.WebApplication.NETCore2 [dependencies]
-- #763 Bump Newtonsoft.Json from 6.0.1 to 13.0.1 in /examples/WireMock.Net.Client.Net472 [dependencies]
-- #765 Update WireMock.Org.Abstractions and WireMock.Org.RestClient [feature]
-- #766 Bump Microsoft.AspNetCore.Http from 2.1.1 to 2.1.22 in /examples/WireMock.Net.StandAlone.Net461 [dependencies]
-- #767 Rename (WireMock.Pact.Models.V2)-Request to PactRequest and -Response to PactResponse [feature]
-- #764 Wrong mapping of method GetAdminMappingsAsync from IWireMockOrgApi [bug]
+# 1.5.3 (29 July 2022)
+- #777 Update Scriban.Signed to version 5.5.0 [feature]
+- #776 Update Scriban.Signed to support more functions, e.g math.random [feature]
 
 The full release notes can be found here: https://github.com/WireMock-Net/WireMock.Net/blob/master/CHANGELOG.md

examples/WireMock.Net.Console.Net472.Classic/Nullable/AllowNullAttribute.cs

@@ -0,0 +1,73 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that <see langword="null"/> is allowed as an input even if the
+    ///     corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class AllowNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="AllowNullAttribute"/> class.
+        /// </summary>
+#endif
+        public AllowNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DisallowNullAttribute.cs

@@ -0,0 +1,73 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that <see langword="null"/> is disallowed as an input even if the
+    ///     corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DisallowNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DisallowNullAttribute"/> class.
+        /// </summary>
+#endif
+        public DisallowNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DoesNotReturnAttribute.cs

@@ -0,0 +1,70 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that a method that will never return under any circumstance.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DoesNotReturnAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DoesNotReturnAttribute"/> class.
+        /// </summary>
+        ///
+#endif
+        public DoesNotReturnAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DoesNotReturnIfAttribute.cs

@@ -0,0 +1,88 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method will not return if the associated <see cref="Boolean"/>
+    ///     parameter is passed the specified value.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DoesNotReturnIfAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the condition parameter value.
+        ///     Code after the method is considered unreachable by diagnostics if the argument
+        ///     to the associated parameter matches this value.
+        /// </summary>
+#endif
+        public bool ParameterValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DoesNotReturnIfAttribute"/>
+        ///     class with the specified parameter value.
+        /// </summary>
+        /// <param name="parameterValue">
+        ///     The condition parameter value.
+        ///     Code after the method is considered unreachable by diagnostics if the argument
+        ///     to the associated parameter matches this value.
+        /// </param>
+#endif
+        public DoesNotReturnIfAttribute(bool parameterValue)
+        {
+            ParameterValue = parameterValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MaybeNullAttribute.cs

@@ -0,0 +1,74 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that an output may be <see langword="null"/> even if the
+    ///     corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter |
+        AttributeTargets.Property | AttributeTargets.ReturnValue,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MaybeNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="MaybeNullAttribute"/> class.
+        /// </summary>
+#endif
+        public MaybeNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MaybeNullWhenAttribute.cs

@@ -0,0 +1,85 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that when a method returns <see cref="ReturnValue"/>, 
+    ///     the parameter may be <see langword="null"/> even if the corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MaybeNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        ///     If the method returns this value, the associated parameter may be <see langword="null"/>.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///      Initializes the attribute with the specified return value condition.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition.
+        ///     If the method returns this value, the associated parameter may be <see langword="null"/>.
+        /// </param>
+#endif
+        public MaybeNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MemberNotNullAttribute.cs

@@ -0,0 +1,96 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method or property will ensure that the listed field and property members have
+    ///     not-<see langword="null"/> values.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MemberNotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets field or property member names.
+        /// </summary>
+#endif
+        public string[] Members { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with a field or property member.
+        /// </summary>
+        /// <param name="member">
+        ///     The field or property member that is promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullAttribute(string member)
+        {
+            Members = new[] { member };
+        }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the list of field and property members.
+        /// </summary>
+        /// <param name="members">
+        ///     The list of field and property members that are promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullAttribute(params string[] members)
+        {
+            Members = members;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MemberNotNullWhenAttribute.cs

@@ -0,0 +1,114 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method or property will ensure that the listed field and property members have
+    ///     non-<see langword="null"/> values when returning with the specified return value condition.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MemberNotNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Gets field or property member names.
+        /// </summary>
+#endif
+        public string[] Members { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition and a field or property member.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition. If the method returns this value,
+        ///     the associated parameter will not be <see langword="null"/>.
+        /// </param>
+        /// <param name="member">
+        ///     The field or property member that is promised to be not-<see langword="null"/>.
+        /// </param>
+#endif
+        public MemberNotNullWhenAttribute(bool returnValue, string member)
+        {
+            ReturnValue = returnValue;
+            Members = new[] { member };
+        }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition and list
+        ///     of field and property members.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition. If the method returns this value,
+        ///     the associated parameter will not be <see langword="null"/>.
+        /// </param>
+        /// <param name="members">
+        ///     The list of field and property members that are promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
+        {
+            ReturnValue = returnValue;
+            Members = members;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullAttribute.cs

@@ -0,0 +1,74 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that an output is not <see langword="null"/> even if the
+    ///     corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter |
+        AttributeTargets.Property | AttributeTargets.ReturnValue,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="NotNullAttribute"/> class.
+        /// </summary>
+#endif
+        public NotNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullIfNotNullAttribute.cs

@@ -0,0 +1,91 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the output will be non-<see langword="null"/> if the
+    ///     named parameter is non-<see langword="null"/>.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue,
+        AllowMultiple = true,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullIfNotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the associated parameter name.
+        ///     The output will be non-<see langword="null"/> if the argument to the
+        ///     parameter specified is non-<see langword="null"/>.
+        /// </summary>
+#endif
+        public string ParameterName { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the associated parameter name.
+        /// </summary>
+        /// <param name="parameterName">
+        ///     The associated parameter name.
+        ///     The output will be non-<see langword="null"/> if the argument to the
+        ///     parameter specified is non-<see langword="null"/>.
+        /// </param>
+#endif
+        public NotNullIfNotNullAttribute(string parameterName)
+        {
+            ParameterName = parameterName;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullWhenAttribute.cs

@@ -0,0 +1,85 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that when a method returns <see cref="ReturnValue"/>,
+    ///     the parameter will not be <see langword="null"/> even if the corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        ///     If the method returns this value, the associated parameter will not be <see langword="null"/>.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition.
+        ///     If the method returns this value, the associated parameter will not be <see langword="null"/>.
+        /// </param>
+#endif
+        public NotNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/WireMock.Net.Console.Net472.Classic.csproj

@@ -54,23 +54,23 @@
     <Reference Include="HandlebarsDotNet.Helpers.Core, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Handlebars.Net.Helpers.Core.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Core.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.DynamicLinq, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.DynamicLinq.2.3.3\lib\net452\HandlebarsDotNet.Helpers.DynamicLinq.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.DynamicLinq, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.DynamicLinq.2.3.5\lib\net452\HandlebarsDotNet.Helpers.DynamicLinq.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Humanizer, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Humanizer.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Humanizer.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Humanizer, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Humanizer.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Humanizer.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Json, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Json.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Json.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Json, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Json.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Json.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Random, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Random.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Random.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Random, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Random.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Random.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Xeger, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Xeger.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Xeger.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Xeger, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Xeger.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Xeger.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.XPath, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.XPath.2.3.3\lib\net452\HandlebarsDotNet.Helpers.XPath.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.XPath, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.XPath.2.3.5\lib\net452\HandlebarsDotNet.Helpers.XPath.dll</HintPath>
     </Reference>
     <Reference Include="Humanizer, Version=2.14.0.0, Culture=neutral, PublicKeyToken=979442b78dfc278e, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Humanizer.Core.2.14.1\lib\netstandard2.0\Humanizer.dll</HintPath>
@@ -246,11 +246,23 @@
     <Reference Include="Microsoft.Net.Http.Headers, Version=2.2.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Microsoft.Net.Http.Headers.2.2.0\lib\netstandard2.0\Microsoft.Net.Http.Headers.dll</HintPath>
     </Reference>
+    <Reference Include="Namotion.Reflection, Version=2.0.10.0, Culture=neutral, PublicKeyToken=c2f9c3bdfae56102, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Namotion.Reflection.2.0.10\lib\net45\Namotion.Reflection.dll</HintPath>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
-    <Reference Include="RandomDataGenerator, Version=1.0.13.0, Culture=neutral, PublicKeyToken=ae5c571d29a3b8d9, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\RandomDataGenerator.Net.1.0.14\lib\net45\RandomDataGenerator.dll</HintPath>
+    <Reference Include="NJsonSchema, Version=10.6.10.0, Culture=neutral, PublicKeyToken=c2f9c3bdfae56102, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NJsonSchema.10.6.10\lib\net45\NJsonSchema.dll</HintPath>
+    </Reference>
+    <Reference Include="NJsonSchema.Extensions, Version=0.1.0.0, Culture=neutral, PublicKeyToken=e52fadf300daf456, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NJsonSchema.Extensions.0.1.0\lib\net45\NJsonSchema.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="NSwag.Core, Version=13.15.10.0, Culture=neutral, PublicKeyToken=c2d88086e098d109, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NSwag.Core.13.15.10\lib\net45\NSwag.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="RandomDataGenerator, Version=1.0.15.0, Culture=neutral, PublicKeyToken=ae5c571d29a3b8d9, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\RandomDataGenerator.Net.1.0.15\lib\net45\RandomDataGenerator.dll</HintPath>
     </Reference>
     <Reference Include="Scriban.Signed, Version=2.1.4.0, Culture=neutral, PublicKeyToken=5675fb69b15f2433, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Scriban.Signed.2.1.4\lib\net45\Scriban.Signed.dll</HintPath>
@@ -289,6 +301,10 @@
     <Reference Include="System.Memory, Version=4.0.1.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Memory.4.5.4\lib\net461\System.Memory.dll</HintPath>
     </Reference>
+    <Reference Include="System.Net" />
+    <Reference Include="System.Net.Http.Formatting, Version=5.2.8.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Microsoft.AspNet.WebApi.Client.5.2.8\lib\net45\System.Net.Http.Formatting.dll</HintPath>
+    </Reference>
     <Reference Include="System.Net.Http.WebRequest" />
     <Reference Include="System.Numerics" />
     <Reference Include="System.Numerics.Vectors, Version=4.1.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
@@ -300,6 +316,7 @@
     <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Runtime.CompilerServices.Unsafe.5.0.0\lib\net45\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
     </Reference>
+    <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Security.Cryptography.Cng, Version=4.3.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Security.Cryptography.Cng.4.5.0\lib\net47\System.Security.Cryptography.Cng.dll</HintPath>
     </Reference>
@@ -325,14 +342,14 @@
     <Reference Include="TinyMapper, Version=3.0.1.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\..\packages\TinyMapper.3.0.3\lib\net40\TinyMapper.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Net, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Net.1.4.41\lib\net461\WireMock.Net.dll</HintPath>
+    <Reference Include="WireMock.Net, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Net.1.5.1\lib\net461\WireMock.Net.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Net.Abstractions, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Net.Abstractions.1.4.41\lib\net451\WireMock.Net.Abstractions.dll</HintPath>
+    <Reference Include="WireMock.Net.Abstractions, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Net.Abstractions.1.5.1\lib\net451\WireMock.Net.Abstractions.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Org.Abstractions, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Org.Abstractions.1.4.41\lib\net45\WireMock.Org.Abstractions.dll</HintPath>
+    <Reference Include="WireMock.Org.Abstractions, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Org.Abstractions.1.5.1\lib\net45\WireMock.Org.Abstractions.dll</HintPath>
     </Reference>
     <Reference Include="XPath2, Version=1.1.3.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
       <HintPath>..\..\packages\XPath2.1.1.3\lib\net452\XPath2.dll</HintPath>
@@ -351,6 +368,17 @@
     <Compile Include="..\WireMock.Net.Console.Net452.Classic\Program.cs">
       <Link>Program.cs</Link>
     </Compile>
+    <Compile Include="Nullable\AllowNullAttribute.cs" />
+    <Compile Include="Nullable\DisallowNullAttribute.cs" />
+    <Compile Include="Nullable\DoesNotReturnAttribute.cs" />
+    <Compile Include="Nullable\DoesNotReturnIfAttribute.cs" />
+    <Compile Include="Nullable\MaybeNullAttribute.cs" />
+    <Compile Include="Nullable\MaybeNullWhenAttribute.cs" />
+    <Compile Include="Nullable\MemberNotNullAttribute.cs" />
+    <Compile Include="Nullable\MemberNotNullWhenAttribute.cs" />
+    <Compile Include="Nullable\NotNullAttribute.cs" />
+    <Compile Include="Nullable\NotNullIfNotNullAttribute.cs" />
+    <Compile Include="Nullable\NotNullWhenAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

examples/WireMock.Net.Console.Net472.Classic/packages.config

@@ -5,12 +5,12 @@
   <package id="Handlebars.Net" version="2.1.2" targetFramework="net472" />
   <package id="Handlebars.Net.Helpers" version="2.3.5" targetFramework="net472" />
   <package id="Handlebars.Net.Helpers.Core" version="2.3.5" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.DynamicLinq" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Humanizer" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Json" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Random" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Xeger" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.XPath" version="2.3.3" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.DynamicLinq" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Humanizer" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Json" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Random" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Xeger" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.XPath" version="2.3.5" targetFramework="net472" />
   <package id="Humanizer" version="2.14.1" targetFramework="net472" />
   <package id="Humanizer.Core" version="2.14.1" targetFramework="net472" />
   <package id="Humanizer.Core.af" version="2.14.1" targetFramework="net472" />
@@ -63,6 +63,7 @@
   <package id="Humanizer.Core.zh-Hant" version="2.14.1" targetFramework="net472" />
   <package id="JmesPath.Net" version="1.0.125" targetFramework="net472" />
   <package id="log4net" version="2.0.14" targetFramework="net472" />
+  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.8" targetFramework="net472" />
   <package id="Microsoft.AspNetCore" version="2.2.0" targetFramework="net472" />
   <package id="Microsoft.AspNetCore.Authentication.Abstractions" version="2.2.0" targetFramework="net472" />
   <package id="Microsoft.AspNetCore.Authentication.Core" version="2.2.0" targetFramework="net472" />
@@ -119,8 +120,13 @@
   <package id="Microsoft.IdentityModel.Protocols.OpenIdConnect" version="6.12.2" targetFramework="net472" />
   <package id="Microsoft.IdentityModel.Tokens" version="6.12.2" targetFramework="net472" />
   <package id="Microsoft.Net.Http.Headers" version="2.2.0" targetFramework="net472" />
+  <package id="Namotion.Reflection" version="2.0.10" targetFramework="net472" />
   <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net472" />
-  <package id="RandomDataGenerator.Net" version="1.0.14" targetFramework="net472" />
+  <package id="NJsonSchema" version="10.6.10" targetFramework="net472" />
+  <package id="NJsonSchema.Extensions" version="0.1.0" targetFramework="net472" />
+  <package id="NSwag.Core" version="13.15.10" targetFramework="net472" />
+  <package id="Nullable" version="1.3.0" targetFramework="net472" developmentDependency="true" />
+  <package id="RandomDataGenerator.Net" version="1.0.15" targetFramework="net472" />
   <package id="Scriban.Signed" version="2.1.4" targetFramework="net472" />
   <package id="SimMetrics.Net" version="1.0.5" targetFramework="net461" />
   <package id="Stef.Validation" version="0.1.0" targetFramework="net472" />
@@ -141,9 +147,9 @@
   <package id="System.Threading.Tasks.Extensions" version="4.5.1" targetFramework="net472" />
   <package id="System.ValueTuple" version="4.5.0" targetFramework="net472" />
   <package id="TinyMapper" version="3.0.3" targetFramework="net472" />
-  <package id="WireMock.Net" version="1.4.41" targetFramework="net472" />
-  <package id="WireMock.Net.Abstractions" version="1.4.41" targetFramework="net472" />
-  <package id="WireMock.Org.Abstractions" version="1.4.41" targetFramework="net472" />
+  <package id="WireMock.Net" version="1.5.1" targetFramework="net472" />
+  <package id="WireMock.Net.Abstractions" version="1.5.1" targetFramework="net472" />
+  <package id="WireMock.Org.Abstractions" version="1.5.1" targetFramework="net472" />
   <package id="XPath2" version="1.1.3" targetFramework="net472" />
   <package id="XPath2.Extensions" version="1.1.3" targetFramework="net472" />
 </packages>

examples/WireMock.Net.StandAlone.Net461/packages.config

@@ -24,7 +24,7 @@
   <package id="Microsoft.AspNetCore.Routing.Abstractions" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.IISIntegration" version="2.1.2" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel" version="2.1.3" targetFramework="net461" />
-  <package id="Microsoft.AspNetCore.Server.Kestrel.Core" version="2.1.3" targetFramework="net461" />
+  <package id="Microsoft.AspNetCore.Server.Kestrel.Core" version="2.1.7" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Https" version="2.1.3" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions" version="2.1.3" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets" version="2.1.3" targetFramework="net461" />

src/WireMock.Net.Abstractions/Admin/Mappings/MatcherModel.cs

@@ -1,48 +1,52 @@
-namespace WireMock.Admin.Mappings
+namespace WireMock.Admin.Mappings;
+
+/// <summary>
+/// MatcherModel
+/// </summary>
+[FluentBuilder.AutoGenerateBuilder]
+public class MatcherModel
 {
     /// <summary>
-    /// MatcherModel
+    /// Gets or sets the name.
     /// </summary>
-    [FluentBuilder.AutoGenerateBuilder]
-    public class MatcherModel
-    {
-        /// <summary>
-        /// Gets or sets the name.
-        /// </summary>
-        public string Name { get; set; }
+    public string Name { get; set; } = null!;
 
-        /// <summary>
-        /// Gets or sets the pattern. Can be a string (default) or an object.
-        /// </summary>
-        public object? Pattern { get; set; }
+    /// <summary>
+    /// Gets or sets the pattern. Can be a string (default) or an object.
+    /// </summary>
+    public object? Pattern { get; set; }
 
-        /// <summary>
-        /// Gets or sets the patterns. Can be array of strings (default) or an array of objects.
-        /// </summary>
-        public object[]? Patterns { get; set; }
+    /// <summary>
+    /// Gets or sets the patterns. Can be array of strings (default) or an array of objects.
+    /// </summary>
+    public object[]? Patterns { get; set; }
 
-        /// <summary>
-        /// Gets or sets the pattern as a file.
-        /// </summary>
-        public string? PatternAsFile { get; set; }
+    /// <summary>
+    /// Gets or sets the pattern as a file.
+    /// </summary>
+    public string? PatternAsFile { get; set; }
 
-        /// <summary>
-        /// Gets or sets the ignore case.
-        /// </summary>
-        public bool? IgnoreCase { get; set; }
+    /// <summary>
+    /// Gets or sets the ignore case.
+    /// </summary>
+    public bool? IgnoreCase { get; set; }
 
-        /// <summary>
-        /// Reject on match.
-        /// </summary>
-        public bool? RejectOnMatch { get; set; }
+    /// <summary>
+    /// Reject on match.
+    /// </summary>
+    public bool? RejectOnMatch { get; set; }
 
-        /// <summary>
-        /// The Operator to use when multiple patterns are defined. Optional.
-        /// - null      = Same as "or".
-        /// - "or"      = Only one pattern should match.
-        /// - "and"     = All patterns should match.
-        /// - "average" = The average value from all patterns.
-        /// </summary>
-        public string? MatchOperator { get; set; }
-    }
+    /// <summary>
+    /// The Operator to use when multiple patterns are defined. Optional.
+    /// - null      = Same as "or".
+    /// - "or"      = Only one pattern should match.
+    /// - "and"     = All patterns should match.
+    /// - "average" = The average value from all patterns.
+    /// </summary>
+    public string? MatchOperator { get; set; }
+
+    /// <summary>
+    /// Support Regex, only used for JsonPartialMatcher.
+    /// </summary>
+    public bool? Regex { get; set; }
 }

src/WireMock.Net.Abstractions/Admin/Mappings/WebhookRequestModel.cs

@@ -15,24 +15,24 @@ namespace WireMock.Admin.Mappings
         public string Url { get; set; }
 
         /// <summary>
-        /// The methods
+        /// The method
         /// </summary>
         public string Method { get; set; }
 
         /// <summary>
         /// Gets or sets the headers.
         /// </summary>
-        public IDictionary<string, string> Headers { get; set; }
+        public IDictionary<string, string>? Headers { get; set; }
 
         /// <summary>
         /// Gets or sets the body.
         /// </summary>
-        public string Body { get; set; }
+        public string? Body { get; set; }
 
         /// <summary>
         /// Gets or sets the body (as JSON object).
         /// </summary>
-        public object BodyAsJson { get; set; }
+        public object? BodyAsJson { get; set; }
 
         /// <summary>
         /// Use ResponseMessage Transformer.

src/WireMock.Net.Abstractions/Matchers/Request/IRequestMatcher.cs

@@ -1,20 +1,17 @@
-using JetBrains.Annotations;
+namespace WireMock.Matchers.Request;
 
-namespace WireMock.Matchers.Request
+/// <summary>
+/// The RequestMatcher interface.
+/// </summary>
+public interface IRequestMatcher
 {
     /// <summary>
-    /// The RequestMatcher interface.
+    /// Determines whether the specified RequestMessage is match.
     /// </summary>
-    public interface IRequestMatcher
-    {
-        /// <summary>
-        /// Determines whether the specified RequestMessage is match.
-        /// </summary>
-        /// <param name="requestMessage">The RequestMessage.</param>
-        /// <param name="requestMatchResult">The RequestMatchResult.</param>
-        /// <returns>
-        /// A value between 0.0 - 1.0 of the similarity.
-        /// </returns>
-        double GetMatchingScore(IRequestMessage requestMessage, IRequestMatchResult requestMatchResult);
-    }
+    /// <param name="requestMessage">The RequestMessage.</param>
+    /// <param name="requestMatchResult">The RequestMatchResult.</param>
+    /// <returns>
+    /// A value between 0.0 - 1.0 of the similarity.
+    /// </returns>
+    double GetMatchingScore(IRequestMessage requestMessage, IRequestMatchResult requestMatchResult);
 }

src/WireMock.Net/Http/HttpResponseMessageHelper.cs

@@ -5,60 +5,64 @@ using System.Net.Http;
 using System.Threading.Tasks;
 using WireMock.Util;
 
-namespace WireMock.Http
+namespace WireMock.Http;
+
+internal static class HttpResponseMessageHelper
 {
-    internal static class HttpResponseMessageHelper
+    public static async Task<ResponseMessage> CreateAsync(
+        HttpResponseMessage httpResponseMessage,
+        Uri requiredUri,
+        Uri originalUri,
+        bool deserializeJson,
+        bool decompressGzipAndDeflate)
     {
-        public static async Task<ResponseMessage> CreateAsync(HttpResponseMessage httpResponseMessage, Uri requiredUri, Uri originalUri, bool deserializeJson, bool decompressGzipAndDeflate)
+        var responseMessage = new ResponseMessage { StatusCode = (int)httpResponseMessage.StatusCode };
+
+        // Set both content and response headers, replacing URLs in values
+        var headers = (httpResponseMessage.Content?.Headers.Union(httpResponseMessage.Headers) ?? Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>()).ToArray();
+        if (httpResponseMessage.Content != null)
         {
-            var responseMessage = new ResponseMessage { StatusCode = (int)httpResponseMessage.StatusCode };
-
-            // Set both content and response headers, replacing URLs in values
-            var headers = (httpResponseMessage.Content?.Headers.Union(httpResponseMessage.Headers) ?? Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>()).ToArray();
-            if (httpResponseMessage.Content != null)
+            var stream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            IEnumerable<string>? contentTypeHeader = null;
+            if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)))
             {
-                var stream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                IEnumerable<string> contentTypeHeader = null;
-                if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)))
-                {
-                    contentTypeHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)).Value;
-                }
-
-                IEnumerable<string> contentEncodingHeader = null;
-                if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)))
-                {
-                    contentEncodingHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)).Value;
-                }
-
-                var bodyParserSettings = new BodyParserSettings
-                {
-                    Stream = stream,
-                    ContentType = contentTypeHeader?.FirstOrDefault(),
-                    DeserializeJson = deserializeJson,
-                    ContentEncoding = contentEncodingHeader?.FirstOrDefault(),
-                    DecompressGZipAndDeflate = decompressGzipAndDeflate
-                };
-                responseMessage.BodyData = await BodyParser.ParseAsync(bodyParserSettings).ConfigureAwait(false);
+                contentTypeHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)).Value;
             }
 
-            foreach (var header in headers)
+            IEnumerable<string>? contentEncodingHeader = null;
+            if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)))
             {
-                // If Location header contains absolute redirect URL, and base URL is one that we proxy to,
-                // we need to replace it to original one.
-                if (string.Equals(header.Key, HttpKnownHeaderNames.Location, StringComparison.OrdinalIgnoreCase)
-                    && Uri.TryCreate(header.Value.First(), UriKind.Absolute, out Uri absoluteLocationUri)
-                    && string.Equals(absoluteLocationUri.Host, requiredUri.Host, StringComparison.OrdinalIgnoreCase))
-                {
-                    var replacedLocationUri = new Uri(originalUri, absoluteLocationUri.PathAndQuery);
-                    responseMessage.AddHeader(header.Key, replacedLocationUri.ToString());
-                }
-                else
-                {
-                    responseMessage.AddHeader(header.Key, header.Value.ToArray());
-                }
+                contentEncodingHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)).Value;
             }
 
-            return responseMessage;
+            var bodyParserSettings = new BodyParserSettings
+            {
+                Stream = stream,
+                ContentType = contentTypeHeader?.FirstOrDefault(),
+                DeserializeJson = deserializeJson,
+                ContentEncoding = contentEncodingHeader?.FirstOrDefault(),
+                DecompressGZipAndDeflate = decompressGzipAndDeflate
+            };
+            responseMessage.BodyData = await BodyParser.ParseAsync(bodyParserSettings).ConfigureAwait(false);
         }
+
+        foreach (var header in headers)
+        {
+            // If Location header contains absolute redirect URL, and base URL is one that we proxy to,
+            // we need to replace it to original one.
+            if (string.Equals(header.Key, HttpKnownHeaderNames.Location, StringComparison.OrdinalIgnoreCase)
+                && Uri.TryCreate(header.Value.First(), UriKind.Absolute, out Uri absoluteLocationUri)
+                && string.Equals(absoluteLocationUri.Host, requiredUri.Host, StringComparison.OrdinalIgnoreCase))
+            {
+                var replacedLocationUri = new Uri(originalUri, absoluteLocationUri.PathAndQuery);
+                responseMessage.AddHeader(header.Key, replacedLocationUri.ToString());
+            }
+            else
+            {
+                responseMessage.AddHeader(header.Key, header.Value.ToArray());
+            }
+        }
+
+        return responseMessage;
     }
 }

src/WireMock.Net/Matchers/AbstractJsonPartialMatcher.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json.Linq;
+using WireMock.Util;
 
 namespace WireMock.Matchers;
 
@@ -9,15 +10,22 @@ namespace WireMock.Matchers;
 /// </summary>
 public abstract class AbstractJsonPartialMatcher : JsonMatcher
 {
+    /// <summary>
+    /// Support Regex
+    /// </summary>
+    public bool Regex { get; }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="AbstractJsonPartialMatcher"/> class.
     /// </summary>
     /// <param name="value">The string value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <summary>
@@ -26,9 +34,11 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <param name="value">The object value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <summary>
@@ -38,9 +48,11 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <param name="value">The value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(matchBehaviour, value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <inheritdoc />
@@ -51,6 +63,17 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
             return true;
         }
 
+        if (Regex && value.Type == JTokenType.String && input != null)
+        {
+            var valueAsString = value.ToString();
+            
+            var (valid, result) = RegexUtils.MatchRegex(valueAsString, input.ToString());
+            if (valid)
+            {
+                return result;
+            }
+        }
+
         if (input == null || value.Type != input.Type)
         {
             return false;

src/WireMock.Net/Matchers/JsonMatcher.cs

@@ -13,12 +13,12 @@ namespace WireMock.Matchers;
 /// </summary>
 public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
 {
-    /// <inheritdoc cref="IValueMatcher.Value"/>
-    public object Value { get; }
-
     /// <inheritdoc cref="IMatcher.Name"/>
     public virtual string Name => "JsonMatcher";
 
+    /// <inheritdoc cref="IValueMatcher.Value"/>
+    public object Value { get; }
+    
     /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
     public MatchBehaviour MatchBehaviour { get; }
 
@@ -68,9 +68,7 @@ public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
 
         Value = value;
         _valueAsJToken = ConvertValueToJToken(value);
-        _jTokenConverter = ignoreCase
-            ? (Func<JToken, JToken>)Rename
-            : jToken => jToken;
+        _jTokenConverter = ignoreCase ? Rename : jToken => jToken;
     }
 
     /// <inheritdoc cref="IObjectMatcher.IsMatch"/>

src/WireMock.Net/Matchers/JsonPartialMatcher.cs

@@ -9,20 +9,20 @@ public class JsonPartialMatcher : AbstractJsonPartialMatcher
     public override string Name => nameof(JsonPartialMatcher);
 
     /// <inheritdoc />
-    public JsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false)
-        : base(matchBehaviour, value, ignoreCase, throwException)
+    public JsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, throwException, regex)
     {
     }
 

src/WireMock.Net/Matchers/JsonPartialWildCardMatcher.cs

@@ -1,5 +1,3 @@
-using JetBrains.Annotations;
-
 namespace WireMock.Matchers;
 
 /// <summary>
@@ -11,20 +9,20 @@ public class JsonPartialWildcardMatcher : AbstractJsonPartialMatcher
     public override string Name => nameof(JsonPartialWildcardMatcher);
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(string value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(object value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false)
-        : base(matchBehaviour, value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, throwException, regex)
     {
     }
 

src/WireMock.Net/Matchers/Request/RequestMessageHeaderMatcher.cs

@@ -23,7 +23,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
     /// <summary>
     /// The name
     /// </summary>
-    public string? Name { get; }
+    public string Name { get; }
 
     /// <value>
     /// The matchers.
@@ -94,6 +94,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
     public RequestMessageHeaderMatcher(params Func<IDictionary<string, string[]>, bool>[] funcs)
     {
         Funcs = Guard.NotNull(funcs);
+        Name = string.Empty; // Not used when Func, but set to a non-null valid value.
     }
 
     /// <inheritdoc />
@@ -121,7 +122,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
 
         if (Matchers != null)
         {
-            if (!headers.ContainsKey(Name!))
+            if (!headers.ContainsKey(Name))
             {
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
@@ -129,7 +130,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
             var results = new List<double>();
             foreach (var matcher in Matchers)
             {
-                var resultsPerMatcher = headers[Name!].Select(v => matcher.IsMatch(v)).ToArray();
+                var resultsPerMatcher = headers[Name].Select(v => matcher.IsMatch(v)).ToArray();
 
                 results.Add(MatchScores.ToScore(resultsPerMatcher, MatchOperator.And));
             }

src/WireMock.Net/Matchers/Request/RequestMessageParamMatcher.cs

@@ -92,7 +92,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
             return MatchScores.ToScore(requestMessage.Query != null && Funcs.Any(f => f(requestMessage.Query)));
         }
 
-        WireMockList<string> valuesPresentInRequestMessage = ((RequestMessage)requestMessage).GetParameter(Key, IgnoreCase ?? false);
+        var valuesPresentInRequestMessage = ((RequestMessage)requestMessage).GetParameter(Key!, IgnoreCase ?? false);
         if (valuesPresentInRequestMessage == null)
         {
             // Key is not present at all, just return Mismatch
@@ -102,7 +102,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
         if (Matchers != null && Matchers.Any())
         {
             // Return the score based on Matchers and valuesPresentInRequestMessage
-            return CalculateScore(valuesPresentInRequestMessage);
+            return CalculateScore(Matchers, valuesPresentInRequestMessage);
         }
 
         if (Matchers == null || !Matchers.Any())
@@ -114,14 +114,14 @@ public class RequestMessageParamMatcher : IRequestMatcher
         return MatchScores.Mismatch;
     }
 
-    private double CalculateScore(WireMockList<string> valuesPresentInRequestMessage)
+    private double CalculateScore(IReadOnlyList<IStringMatcher> matchers, WireMockList<string> valuesPresentInRequestMessage)
     {
         var total = new List<double>();
 
         // If the total patterns in all matchers > values in message, use the matcher as base
-        if (Matchers.Sum(m => m.GetPatterns().Length) > valuesPresentInRequestMessage.Count)
+        if (matchers.Sum(m => m.GetPatterns().Length) > valuesPresentInRequestMessage.Count)
         {
-            foreach (var matcher in Matchers)
+            foreach (var matcher in matchers)
             {
                 double score = 0d;
                 foreach (string valuePresentInRequestMessage in valuesPresentInRequestMessage)
@@ -136,7 +136,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
         {
             foreach (string valuePresentInRequestMessage in valuesPresentInRequestMessage)
             {
-                double score = Matchers.Max(m => m.IsMatch(valuePresentInRequestMessage));
+                double score = matchers.Max(m => m.IsMatch(valuePresentInRequestMessage));
                 total.Add(score);
             }
         }

src/WireMock.Net/Owin/Mappers/OwinRequestMapper.cs

@@ -27,8 +27,8 @@ namespace WireMock.Owin.Mappers
 
             string method = request.Method;
 
-            Dictionary<string, string[]> headers = null;
-            IEnumerable<string> contentEncodingHeader = null;
+            Dictionary<string, string[]>? headers = null;
+            IEnumerable<string>? contentEncodingHeader = null;
             if (request.Headers.Any())
             {
                 headers = new Dictionary<string, string[]>();
@@ -43,7 +43,7 @@ namespace WireMock.Owin.Mappers
                 }
             }
 
-            IDictionary<string, string> cookies = null;
+            IDictionary<string, string>? cookies = null;
             if (request.Cookies.Any())
             {
                 cookies = new Dictionary<string, string>();
@@ -53,7 +53,7 @@ namespace WireMock.Owin.Mappers
                 }
             }
 
-            IBodyData body = null;
+            IBodyData? body = null;
             if (request.Body != null && BodyParser.ShouldParseBody(method, options.AllowBodyForAllHttpMethods == true))
             {
                 var bodyParserSettings = new BodyParserSettings

src/WireMock.Net/RegularExpressions/RegexExtended.cs

@@ -3,88 +3,87 @@ using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using Stef.Validation;
 
-namespace WireMock.RegularExpressions
+namespace WireMock.RegularExpressions;
+
+/// <summary>
+/// Extension to the <see cref="Regex"/> object, adding support for GUID tokens for matching on.
+/// </summary>
+#if !NETSTANDARD1_3
+[Serializable]
+#endif
+internal class RegexExtended : Regex
 {
-    /// <summary>
-    /// Extension to the <see cref="Regex"/> object, adding support for GUID tokens for matching on.
-    /// </summary>
-#if !NETSTANDARD1_3
-    [Serializable]
-#endif
-    internal class RegexExtended : Regex
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern) : this(pattern, RegexOptions.None)
     {
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern) : this(pattern, RegexOptions.None)
-        {
-        }
+    }
 
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern, RegexOptions options) :
-            this(pattern, options, Regex.InfiniteMatchTimeout)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern, RegexOptions options) :
+        this(pattern, options, Regex.InfiniteMatchTimeout)
+    {
+    }
 
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern, RegexOptions options, TimeSpan matchTimeout) :
-            base(ReplaceGuidPattern(pattern), options, matchTimeout)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern, RegexOptions options, TimeSpan matchTimeout) :
+        base(ReplaceGuidPattern(pattern), options, matchTimeout)
+    {
+    }
 
 #if !NETSTANDARD1_3
-        /// <inheritdoc cref="Regex"/>
-        protected RegexExtended(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
-            base(info, context)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    protected RegexExtended(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
+        base(info, context)
+    {
+    }
 #endif
-        // Dictionary of various Guid tokens with a corresponding regular expression pattern to use instead.
-        private static readonly Dictionary<string, string> GuidTokenPatterns = new Dictionary<string, string>
+    // Dictionary of various Guid tokens with a corresponding regular expression pattern to use instead.
+    private static readonly Dictionary<string, string> GuidTokenPatterns = new()
+    {
+        // Lower case format `B` Guid pattern
+        { @"\guidb", @"(\{[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\})" },
+
+        // Upper case format `B` Guid pattern
+        { @"\GUIDB", @"(\{[A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\})" },
+
+        // Lower case format `D` Guid pattern
+        { @"\guidd", "([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12})" },
+
+        // Upper case format `D` Guid pattern
+        { @"\GUIDD", "([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12})" },
+
+        // Lower case format `N` Guid pattern
+        { @"\guidn", "([a-z0-9]{32})" },
+
+        // Upper case format `N` Guid pattern
+        { @"\GUIDN", "([A-Z0-9]{32})" },
+
+        // Lower case format `P` Guid pattern
+        { @"\guidp", @"(\([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\))" },
+
+        // Upper case format `P` Guid pattern
+        { @"\GUIDP", @"(\([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\))" },
+
+        // Lower case format `X` Guid pattern
+        { @"\guidx", @"(\{0x[a-f0-9]{8},0x[a-f0-9]{4},0x[a-f0-9]{4},\{(0x[a-f0-9]{2},){7}(0x[a-f0-9]{2})\}\})" },
+
+        // Upper case format `X` Guid pattern
+        { @"\GUIDX", @"(\{0x[A-F0-9]{8},0x[A-F0-9]{4},0x[A-F0-9]{4},\{(0x[A-F0-9]{2},){7}(0x[A-F0-9]{2})\}\})" },
+    };
+
+    /// <summary>
+    /// Replaces all instances of valid GUID tokens with the correct regular expression to match.
+    /// </summary>
+    /// <param name="pattern">Pattern to replace token for.</param>
+    private static string ReplaceGuidPattern(string pattern)
+    {
+        Guard.NotNull(pattern, nameof(pattern));
+
+        foreach (var tokenPattern in GuidTokenPatterns)
         {
-            // Lower case format `B` Guid pattern
-            { @"\guidb", @"(\{[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\})" },
-
-            // Upper case format `B` Guid pattern
-            { @"\GUIDB", @"(\{[A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\})" },
-
-            // Lower case format `D` Guid pattern
-            { @"\guidd", "([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12})" },
-
-            // Upper case format `D` Guid pattern
-            { @"\GUIDD", "([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12})" },
-
-            // Lower case format `N` Guid pattern
-            { @"\guidn", "([a-z0-9]{32})" },
-
-            // Upper case format `N` Guid pattern
-            { @"\GUIDN", "([A-Z0-9]{32})" },
-
-            // Lower case format `P` Guid pattern
-            { @"\guidp", @"(\([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\))" },
-
-            // Upper case format `P` Guid pattern
-            { @"\GUIDP", @"(\([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\))" },
-
-            // Lower case format `X` Guid pattern
-            { @"\guidx", @"(\{0x[a-f0-9]{8},0x[a-f0-9]{4},0x[a-f0-9]{4},\{(0x[a-f0-9]{2},){7}(0x[a-f0-9]{2})\}\})" },
-
-            // Upper case format `X` Guid pattern
-            { @"\GUIDX", @"(\{0x[A-F0-9]{8},0x[A-F0-9]{4},0x[A-F0-9]{4},\{(0x[A-F0-9]{2},){7}(0x[A-F0-9]{2})\}\})" },
-        };
-
-        /// <summary>
-        /// Replaces all instances of valid GUID tokens with the correct regular expression to match.
-        /// </summary>
-        /// <param name="pattern">Pattern to replace token for.</param>
-        private static string ReplaceGuidPattern(string pattern)
-        {
-            Guard.NotNull(pattern, nameof(pattern));
-
-            foreach (var tokenPattern in GuidTokenPatterns)
-            {
-                pattern = pattern.Replace(tokenPattern.Key, tokenPattern.Value);
-            }
-
-            return pattern;
+            pattern = pattern.Replace(tokenPattern.Key, tokenPattern.Value);
         }
+
+        return pattern;
     }
 }

src/WireMock.Net/RequestMessage.cs

@@ -1,159 +1,157 @@
 // This source file is based on mock4net by Alexandre Victoor which is licensed under the Apache 2.0 License.
 // For more details see 'mock4net/LICENSE.txt' and 'mock4net/readme.md' in this project root.
-using JetBrains.Annotations;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using Stef.Validation;
 using WireMock.Models;
 using WireMock.Types;
 using WireMock.Util;
-using Stef.Validation;
 
-namespace WireMock
+namespace WireMock;
+
+/// <summary>
+/// The RequestMessage.
+/// </summary>
+public class RequestMessage : IRequestMessage
 {
+    /// <inheritdoc cref="IRequestMessage.ClientIP" />
+    public string ClientIP { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Url" />
+    public string Url { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsoluteUrl" />
+    public string AbsoluteUrl { get; }
+
+    /// <inheritdoc cref="IRequestMessage.ProxyUrl" />
+    public string ProxyUrl { get; set; }
+
+    /// <inheritdoc cref="IRequestMessage.DateTime" />
+    public DateTime DateTime { get; set; }
+
+    /// <inheritdoc cref="IRequestMessage.Path" />
+    public string Path { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsolutePath" />
+    public string AbsolutePath { get; }
+
+    /// <inheritdoc cref="IRequestMessage.PathSegments" />
+    public string[] PathSegments { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsolutePathSegments" />
+    public string[] AbsolutePathSegments { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Method" />
+    public string Method { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Headers" />
+    public IDictionary<string, WireMockList<string>>? Headers { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Cookies" />
+    public IDictionary<string, string>? Cookies { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Query" />
+    public IDictionary<string, WireMockList<string>>? Query { get; }
+
+    /// <inheritdoc cref="IRequestMessage.RawQuery" />
+    public string RawQuery { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyData" />
+    public IBodyData? BodyData { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Body" />
+    public string Body { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyAsJson" />
+    public object BodyAsJson { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyAsBytes" />
+    public byte[] BodyAsBytes { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedBodyType" />
+    public string DetectedBodyType { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedBodyTypeFromContentType" />
+    public string DetectedBodyTypeFromContentType { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedCompression" />
+    public string DetectedCompression { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Host" />
+    public string Host { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Protocol" />
+    public string Protocol { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Port" />
+    public int Port { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Origin" />
+    public string Origin { get; }
+
     /// <summary>
-    /// The RequestMessage.
+    /// Initializes a new instance of the <see cref="RequestMessage"/> class.
     /// </summary>
-    public class RequestMessage : IRequestMessage
+    /// <param name="urlDetails">The original url details.</param>
+    /// <param name="method">The HTTP method.</param>
+    /// <param name="clientIP">The client IP Address.</param>
+    /// <param name="bodyData">The BodyData.</param>
+    /// <param name="headers">The headers.</param>
+    /// <param name="cookies">The cookies.</param>
+    public RequestMessage(UrlDetails urlDetails, string method, string clientIP, IBodyData? bodyData = null, IDictionary<string, string[]>? headers = null, IDictionary<string, string>? cookies = null)
     {
-        /// <inheritdoc cref="IRequestMessage.ClientIP" />
-        public string ClientIP { get; }
+        Guard.NotNull(urlDetails, nameof(urlDetails));
+        Guard.NotNull(method, nameof(method));
+        Guard.NotNull(clientIP, nameof(clientIP));
 
-        /// <inheritdoc cref="IRequestMessage.Url" />
-        public string Url { get; }
+        AbsoluteUrl = urlDetails.AbsoluteUrl.ToString();
+        Url = urlDetails.Url.ToString();
+        Protocol = urlDetails.Url.Scheme;
+        Host = urlDetails.Url.Host;
+        Port = urlDetails.Url.Port;
+        Origin = $"{Protocol}://{Host}:{Port}";
 
-        /// <inheritdoc cref="IRequestMessage.AbsoluteUrl" />
-        public string AbsoluteUrl { get; }
+        AbsolutePath = WebUtility.UrlDecode(urlDetails.AbsoluteUrl.AbsolutePath);
+        Path = WebUtility.UrlDecode(urlDetails.Url.AbsolutePath);
+        PathSegments = Path.Split('/').Skip(1).ToArray();
+        AbsolutePathSegments = AbsolutePath.Split('/').Skip(1).ToArray();
 
-        /// <inheritdoc cref="IRequestMessage.ProxyUrl" />
-        public string ProxyUrl { get; set; }
+        Method = method;
+        ClientIP = clientIP;
 
-        /// <inheritdoc cref="IRequestMessage.DateTime" />
-        public DateTime DateTime { get; set; }
+        BodyData = bodyData;
 
-        /// <inheritdoc cref="IRequestMessage.Path" />
-        public string Path { get; }
+        // Convenience getters for e.g. Handlebars
+        Body = BodyData?.BodyAsString;
+        BodyAsJson = BodyData?.BodyAsJson;
+        BodyAsBytes = BodyData?.BodyAsBytes;
+        DetectedBodyType = BodyData?.DetectedBodyType.ToString();
+        DetectedBodyTypeFromContentType = BodyData?.DetectedBodyTypeFromContentType.ToString();
+        DetectedCompression = BodyData?.DetectedCompression;
 
-        /// <inheritdoc cref="IRequestMessage.AbsolutePath" />
-        public string AbsolutePath { get; }
+        Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
+        Cookies = cookies;
+        RawQuery = urlDetails.Url.Query;
+        Query = QueryStringParser.Parse(RawQuery);
+    }
 
-        /// <inheritdoc cref="IRequestMessage.PathSegments" />
-        public string[] PathSegments { get; }
-
-        /// <inheritdoc cref="IRequestMessage.AbsolutePathSegments" />
-        public string[] AbsolutePathSegments { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Method" />
-        public string Method { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Headers" />
-        public IDictionary<string, WireMockList<string>>? Headers { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Cookies" />
-        public IDictionary<string, string>? Cookies { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Query" />
-        public IDictionary<string, WireMockList<string>>? Query { get; }
-
-        /// <inheritdoc cref="IRequestMessage.RawQuery" />
-        public string RawQuery { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyData" />
-        public IBodyData? BodyData { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Body" />
-        public string Body { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyAsJson" />
-        public object BodyAsJson { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyAsBytes" />
-        public byte[] BodyAsBytes { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedBodyType" />
-        public string DetectedBodyType { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedBodyTypeFromContentType" />
-        public string DetectedBodyTypeFromContentType { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedCompression" />
-        public string DetectedCompression { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Host" />
-        public string Host { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Protocol" />
-        public string Protocol { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Port" />
-        public int Port { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Origin" />
-        public string Origin { get; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestMessage"/> class.
-        /// </summary>
-        /// <param name="urlDetails">The original url details.</param>
-        /// <param name="method">The HTTP method.</param>
-        /// <param name="clientIP">The client IP Address.</param>
-        /// <param name="bodyData">The BodyData.</param>
-        /// <param name="headers">The headers.</param>
-        /// <param name="cookies">The cookies.</param>
-        public RequestMessage(UrlDetails urlDetails, string method, string clientIP, IBodyData? bodyData = null, IDictionary<string, string[]>? headers = null, IDictionary<string, string>? cookies = null)
+    /// <summary>
+    /// Get a query parameter.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
+    /// <returns>The query parameter.</returns>
+    public WireMockList<string>? GetParameter(string key, bool ignoreCase = false)
+    {
+        if (Query == null)
         {
-            Guard.NotNull(urlDetails, nameof(urlDetails));
-            Guard.NotNull(method, nameof(method));
-            Guard.NotNull(clientIP, nameof(clientIP));
-
-            AbsoluteUrl = urlDetails.AbsoluteUrl.ToString();
-            Url = urlDetails.Url.ToString();
-            Protocol = urlDetails.Url.Scheme;
-            Host = urlDetails.Url.Host;
-            Port = urlDetails.Url.Port;
-            Origin = $"{Protocol}://{Host}:{Port}";
-
-            AbsolutePath = WebUtility.UrlDecode(urlDetails.AbsoluteUrl.AbsolutePath);
-            Path = WebUtility.UrlDecode(urlDetails.Url.AbsolutePath);
-            PathSegments = Path.Split('/').Skip(1).ToArray();
-            AbsolutePathSegments = AbsolutePath.Split('/').Skip(1).ToArray();
-
-            Method = method;
-            ClientIP = clientIP;
-
-            BodyData = bodyData;
-
-            // Convenience getters for e.g. Handlebars
-            Body = BodyData?.BodyAsString;
-            BodyAsJson = BodyData?.BodyAsJson;
-            BodyAsBytes = BodyData?.BodyAsBytes;
-            DetectedBodyType = BodyData?.DetectedBodyType.ToString();
-            DetectedBodyTypeFromContentType = BodyData?.DetectedBodyTypeFromContentType.ToString();
-            DetectedCompression = BodyData?.DetectedCompression;
-
-            Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
-            Cookies = cookies;
-            RawQuery = urlDetails.Url.Query;
-            Query = QueryStringParser.Parse(RawQuery);
+            return null;
         }
 
-        /// <summary>
-        /// Get a query parameter.
-        /// </summary>
-        /// <param name="key">The key.</param>
-        /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
-        /// <returns>The query parameter.</returns>
-        public WireMockList<string>? GetParameter(string? key, bool ignoreCase = false)
-        {
-            if (Query == null)
-            {
-                return null;
-            }
+        var query = !ignoreCase ? Query : new Dictionary<string, WireMockList<string>>(Query, StringComparer.OrdinalIgnoreCase);
 
-            var query = !ignoreCase ? Query : new Dictionary<string, WireMockList<string>>(Query, StringComparer.OrdinalIgnoreCase);
-
-            return query.ContainsKey(key) ? query[key] : null;
-        }
+        return query.ContainsKey(key) ? query[key] : null;
     }
 }

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -47,6 +47,7 @@ internal class MatcherMapper
         bool ignoreCase = matcher.IgnoreCase == true;
         bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
         bool useRegexExtended = _settings.UseRegexExtended == true;
+        bool useRegex = matcher.Regex == true;
 
         switch (matcherName)
         {
@@ -79,11 +80,11 @@ internal class MatcherMapper
 
             case nameof(JsonPartialMatcher):
                 var valueForJsonPartialMatcher = matcher.Pattern ?? matcher.Patterns;
-                return new JsonPartialMatcher(matchBehaviour, valueForJsonPartialMatcher!, ignoreCase, throwExceptionWhenMatcherFails);
+                return new JsonPartialMatcher(matchBehaviour, valueForJsonPartialMatcher!, ignoreCase, throwExceptionWhenMatcherFails, useRegex);
 
             case nameof(JsonPartialWildcardMatcher):
                 var valueForJsonPartialWildcardMatcher = matcher.Pattern ?? matcher.Patterns;
-                return new JsonPartialWildcardMatcher(matchBehaviour, valueForJsonPartialWildcardMatcher!, ignoreCase, throwExceptionWhenMatcherFails);
+                return new JsonPartialWildcardMatcher(matchBehaviour, valueForJsonPartialWildcardMatcher!, ignoreCase, throwExceptionWhenMatcherFails, useRegex);
 
             case nameof(JsonPathMatcher):
                 return new JsonPathMatcher(matchBehaviour, throwExceptionWhenMatcherFails, matchOperator, stringPatterns);
@@ -146,6 +147,17 @@ internal class MatcherMapper
             Name = matcher.Name
         };
 
+        switch (matcher)
+        {
+            case JsonPartialMatcher jsonPartialMatcher:
+                model.Regex = jsonPartialMatcher.Regex;
+                break;
+
+            case JsonPartialWildcardMatcher jsonPartialWildcardMatcher:
+                model.Regex = jsonPartialWildcardMatcher.Regex;
+                break;
+        }
+
         switch (matcher)
         {
             // If the matcher is a IStringMatcher, get the operator & patterns.

src/WireMock.Net/Server/WireMockServer.Admin.cs

@@ -293,7 +293,7 @@ public partial class WireMockServer
 
     private IResponseMessage SettingsUpdate(IRequestMessage requestMessage)
     {
-        var settings = DeserializeObject<SettingsModel>(requestMessage);
+        var settings = DeserializeObject<SettingsModel>(requestMessage)!;
 
         // _settings
         _settings.AllowBodyForAllHttpMethods = settings.AllowBodyForAllHttpMethods;

src/WireMock.Net/Settings/WireMockServerSettings.cs

@@ -9,9 +9,9 @@ using WireMock.Handlers;
 using WireMock.Logging;
 using WireMock.Matchers;
 using WireMock.RegularExpressions;
-using WireMock.Types;
 #if USE_ASPNETCORE
 using Microsoft.Extensions.DependencyInjection;
+using WireMock.Types;
 #endif
 
 namespace WireMock.Settings

src/WireMock.Net/Transformers/Scriban/WireMockListAccessor.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Scriban;
 using Scriban.Parsing;
@@ -50,6 +50,20 @@ namespace WireMock.Transformers.Scriban
         {
             throw new NotImplementedException();
         }
+
+        public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasIndexer => throw new NotImplementedException();
+
+        public Type IndexType => throw new NotImplementedException();
         #endregion
     }
 }

src/WireMock.Net/Transformers/Scriban/WireMockTemplateContext.cs

@@ -1,19 +1,15 @@
-using Scriban;
+using Scriban;
 using Scriban.Runtime;
 using WireMock.Types;
 
-namespace WireMock.Transformers.Scriban
-{
-    internal class WireMockTemplateContext: TemplateContext
-    {
-        protected override IObjectAccessor GetMemberAccessorImpl(object target)
-        {
-            if (target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>))
-            {
-                return new WireMockListAccessor();
-            }
+namespace WireMock.Transformers.Scriban;
 
-            return base.GetMemberAccessorImpl(target);
-        }
+internal class WireMockTemplateContext : TemplateContext
+{
+    protected override IObjectAccessor GetMemberAccessorImpl(object target)
+    {
+        return target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>) ?
+            new WireMockListAccessor() :
+            base.GetMemberAccessorImpl(target);
     }
 }

src/WireMock.Net/Util/BodyParser.cs

@@ -4,180 +4,176 @@ using System.Linq;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
+using Stef.Validation;
 using WireMock.Http;
 using WireMock.Matchers;
 using WireMock.Types;
-using Stef.Validation;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class BodyParser
 {
-    internal static class BodyParser
+    private static readonly Encoding DefaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
+    private static readonly Encoding[] SupportedBodyAsStringEncodingForMultipart = { DefaultEncoding, Encoding.ASCII };
+
+    /*
+        HEAD - No defined body semantics.
+        GET - No defined body semantics.
+        PUT - Body supported.
+        POST - Body supported.
+        DELETE - No defined body semantics.
+        TRACE - Body not supported.
+        OPTIONS - Body supported but no semantics on usage (maybe in the future).
+        CONNECT - No defined body semantics
+        PATCH - Body supported.
+    */
+    private static readonly IDictionary<string, bool> BodyAllowedForMethods = new Dictionary<string, bool>
     {
-        private static readonly Encoding DefaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
-        private static readonly Encoding[] SupportedBodyAsStringEncodingForMultipart = { DefaultEncoding, Encoding.ASCII };
+        { HttpRequestMethods.HEAD, false },
+        { HttpRequestMethods.GET, false },
+        { HttpRequestMethods.PUT, true },
+        { HttpRequestMethods.POST, true },
+        { HttpRequestMethods.DELETE, true },
+        { HttpRequestMethods.TRACE, false },
+        { HttpRequestMethods.OPTIONS, true },
+        { HttpRequestMethods.CONNECT, false },
+        { HttpRequestMethods.PATCH, true }
+    };
 
-        /*
-            HEAD - No defined body semantics.
-            GET - No defined body semantics.
-            PUT - Body supported.
-            POST - Body supported.
-            DELETE - No defined body semantics.
-            TRACE - Body not supported.
-            OPTIONS - Body supported but no semantics on usage (maybe in the future).
-            CONNECT - No defined body semantics
-            PATCH - Body supported.
-        */
-        private static readonly IDictionary<string, bool> BodyAllowedForMethods = new Dictionary<string, bool>
+    private static readonly IStringMatcher[] MultipartContentTypesMatchers = {
+        new WildcardMatcher("multipart/*", true)
+    };
+
+    private static readonly IStringMatcher[] JsonContentTypesMatchers = {
+        new WildcardMatcher("application/json", true),
+        new WildcardMatcher("application/vnd.*+json", true)
+    };
+
+    private static readonly IStringMatcher[] TextContentTypeMatchers =
+    {
+        new WildcardMatcher("text/*", true),
+        new RegexMatcher("^application\\/(java|type)script$", true),
+        new WildcardMatcher("application/*xml", true),
+        new WildcardMatcher("application/x-www-form-urlencoded", true)
+    };
+
+    public static bool ShouldParseBody(string? httpMethod, bool allowBodyForAllHttpMethods)
+    {
+        if (string.IsNullOrEmpty(httpMethod))
         {
-            { HttpRequestMethods.HEAD, false },
-            { HttpRequestMethods.GET, false },
-            { HttpRequestMethods.PUT, true },
-            { HttpRequestMethods.POST, true },
-            { HttpRequestMethods.DELETE, true },
-            { HttpRequestMethods.TRACE, false },
-            { HttpRequestMethods.OPTIONS, true },
-            { HttpRequestMethods.CONNECT, false },
-            { HttpRequestMethods.PATCH, true }
-        };
+            return false;
+        }
 
-        private static readonly IStringMatcher[] MultipartContentTypesMatchers = {
-            new WildcardMatcher("multipart/*", true)
-        };
-
-        private static readonly IStringMatcher[] JsonContentTypesMatchers = {
-            new WildcardMatcher("application/json", true),
-            new WildcardMatcher("application/vnd.*+json", true)
-        };
-
-        private static readonly IStringMatcher[] TextContentTypeMatchers =
+        if (allowBodyForAllHttpMethods)
         {
-            new WildcardMatcher("text/*", true),
-            new RegexMatcher("^application\\/(java|type)script$", true),
-            new WildcardMatcher("application/*xml", true),
-            new WildcardMatcher("application/x-www-form-urlencoded", true)
-        };
-
-        public static bool ShouldParseBody([CanBeNull] string httpMethod, bool allowBodyForAllHttpMethods)
-        {
-            if (string.IsNullOrEmpty(httpMethod))
-            {
-                return false;
-            }
-
-            if (allowBodyForAllHttpMethods)
-            {
-                return true;
-            }
-
-            if (BodyAllowedForMethods.TryGetValue(httpMethod.ToUpper(), out bool allowed))
-            {
-                return allowed;
-            }
-
-            // If we don't have any knowledge of this method, we should assume that a body *may*
-            // be present, so we should parse it if it is. Therefore, if a new method is added to
-            // the HTTP Method Registry, we only really need to add it to BodyAllowedForMethods if
-            // we want to make it clear that a body is *not* allowed.
             return true;
         }
 
-        public static BodyType DetectBodyTypeFromContentType([CanBeNull] string contentTypeValue)
+        if (BodyAllowedForMethods.TryGetValue(httpMethod!.ToUpper(), out bool allowed))
         {
-            if (string.IsNullOrEmpty(contentTypeValue) || !MediaTypeHeaderValue.TryParse(contentTypeValue, out MediaTypeHeaderValue contentType))
-            {
-                return BodyType.Bytes;
-            }
+            return allowed;
+        }
 
-            if (TextContentTypeMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.String;
-            }
-
-            if (JsonContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.Json;
-            }
-
-            if (MultipartContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.MultiPart;
-            }
+        // If we don't have any knowledge of this method, we should assume that a body *may*
+        // be present, so we should parse it if it is. Therefore, if a new method is added to
+        // the HTTP Method Registry, we only really need to add it to BodyAllowedForMethods if
+        // we want to make it clear that a body is *not* allowed.
+        return true;
+    }
 
+    public static BodyType DetectBodyTypeFromContentType(string? contentTypeValue)
+    {
+        if (string.IsNullOrEmpty(contentTypeValue) || !MediaTypeHeaderValue.TryParse(contentTypeValue, out MediaTypeHeaderValue contentType))
+        {
             return BodyType.Bytes;
         }
 
-        public static async Task<BodyData> ParseAsync([NotNull] BodyParserSettings settings)
+        if (TextContentTypeMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
         {
-            Guard.NotNull(settings, nameof(settings));
+            return BodyType.String;
+        }
 
-            var bodyWithContentEncoding = await ReadBytesAsync(settings.Stream, settings.ContentEncoding, settings.DecompressGZipAndDeflate).ConfigureAwait(false);
-            var data = new BodyData
-            {
-                BodyAsBytes = bodyWithContentEncoding.Bytes,
-                DetectedCompression = bodyWithContentEncoding.ContentType,
-                DetectedBodyType = BodyType.Bytes,
-                DetectedBodyTypeFromContentType = DetectBodyTypeFromContentType(settings.ContentType)
-            };
+        if (JsonContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
+        {
+            return BodyType.Json;
+        }
 
-            // In case of MultiPart: check if the BodyAsBytes is a valid UTF8 or ASCII string, in that case read as String else keep as-is
-            if (data.DetectedBodyTypeFromContentType == BodyType.MultiPart)
-            {
-                if (BytesEncodingUtils.TryGetEncoding(data.BodyAsBytes, out Encoding encoding) &&
-                    SupportedBodyAsStringEncodingForMultipart.Select(x => x.Equals(encoding)).Any())
-                {
-                    data.BodyAsString = encoding.GetString(data.BodyAsBytes);
-                    data.Encoding = encoding;
-                    data.DetectedBodyType = BodyType.String;
-                }
-   
-                return data;
-            }
+        if (MultipartContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
+        {
+            return BodyType.MultiPart;
+        }
 
-            // Try to get the body as String
-            try
+        return BodyType.Bytes;
+    }
+
+    public static async Task<BodyData> ParseAsync(BodyParserSettings settings)
+    {
+        Guard.NotNull(settings);
+
+        var bodyWithContentEncoding = await ReadBytesAsync(settings.Stream, settings.ContentEncoding, settings.DecompressGZipAndDeflate).ConfigureAwait(false);
+        var data = new BodyData
+        {
+            BodyAsBytes = bodyWithContentEncoding.Bytes,
+            DetectedCompression = bodyWithContentEncoding.ContentType,
+            DetectedBodyType = BodyType.Bytes,
+            DetectedBodyTypeFromContentType = DetectBodyTypeFromContentType(settings.ContentType)
+        };
+
+        // In case of MultiPart: check if the BodyAsBytes is a valid UTF8 or ASCII string, in that case read as String else keep as-is
+        if (data.DetectedBodyTypeFromContentType == BodyType.MultiPart)
+        {
+            if (BytesEncodingUtils.TryGetEncoding(data.BodyAsBytes, out Encoding encoding) &&
+                SupportedBodyAsStringEncodingForMultipart.Select(x => x.Equals(encoding)).Any())
             {
-                data.BodyAsString = DefaultEncoding.GetString(data.BodyAsBytes);
-                data.Encoding = DefaultEncoding;
+                data.BodyAsString = encoding.GetString(data.BodyAsBytes);
+                data.Encoding = encoding;
                 data.DetectedBodyType = BodyType.String;
-
-                // If string is not null or empty, try to deserialize the string to a JObject
-                if (settings.DeserializeJson && !string.IsNullOrEmpty(data.BodyAsString))
-                {
-                    try
-                    {
-                        data.BodyAsJson = JsonUtils.DeserializeObject(data.BodyAsString);
-                        data.DetectedBodyType = BodyType.Json;
-                    }
-                    catch
-                    {
-                        // JsonConvert failed, just ignore.
-                    }
-                }
-            }
-            catch
-            {
-                // Reading as string failed, just ignore
             }
 
             return data;
         }
 
-        private static async Task<(string ContentType, byte[] Bytes)> ReadBytesAsync(Stream stream, string contentEncoding = null, bool decompressGZipAndDeflate = true)
+        // Try to get the body as String or Json
+        try
         {
-            using (var memoryStream = new MemoryStream())
+            data.BodyAsString = DefaultEncoding.GetString(data.BodyAsBytes);
+            data.Encoding = DefaultEncoding;
+            data.DetectedBodyType = BodyType.String;
+
+            // If string is not null or empty, try to deserialize the string to a JObject
+            if (settings.DeserializeJson && !string.IsNullOrEmpty(data.BodyAsString))
             {
-                await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
-                byte[] data = memoryStream.ToArray();
-
-                string type = contentEncoding?.ToLowerInvariant();
-                if (decompressGZipAndDeflate && (type == "gzip" || type == "deflate"))
+                try
                 {
-                    return (type, CompressionUtils.Decompress(type, data));
+                    data.BodyAsJson = JsonUtils.DeserializeObject(data.BodyAsString);
+                    data.DetectedBodyType = BodyType.Json;
+                }
+                catch
+                {
+                    // JsonConvert failed, just ignore.
                 }
-
-                return (null, data);
             }
         }
+        catch
+        {
+            // Reading as string failed, just ignore
+        }
+
+        return data;
+    }
+
+    private static async Task<(string? ContentType, byte[] Bytes)> ReadBytesAsync(Stream stream, string? contentEncoding = null, bool decompressGZipAndDeflate = true)
+    {
+        using var memoryStream = new MemoryStream();
+        await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
+        byte[] data = memoryStream.ToArray();
+
+        var type = contentEncoding?.ToLowerInvariant();
+        if (decompressGZipAndDeflate && type is "gzip" or "deflate")
+        {
+            return (type, CompressionUtils.Decompress(type, data));
+        }
+
+        return (null, data);
     }
 }

src/WireMock.Net/Util/BodyParserSettings.cs

@@ -1,17 +1,16 @@
-using System.IO;
+using System.IO;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal class BodyParserSettings
 {
-    internal class BodyParserSettings
-    {
-        public Stream Stream { get; set; }
+    public Stream Stream { get; set; } = null!;
 
-        public string ContentType { get; set; }
+    public string? ContentType { get; set; }
 
-        public string ContentEncoding { get; set; }
+    public string? ContentEncoding { get; set; }
 
-        public bool DecompressGZipAndDeflate { get; set; } = true;
+    public bool DecompressGZipAndDeflate { get; set; } = true;
 
-        public bool DeserializeJson { get; set; } = true;
-    }
+    public bool DeserializeJson { get; set; } = true;
 }

src/WireMock.Net/Util/RegexUtils.cs

@@ -1,24 +1,53 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Text.RegularExpressions;
+using WireMock.RegularExpressions;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class RegexUtils
 {
-    internal static class RegexUtils
+    private static readonly TimeSpan RegexTimeOut = new(0, 0, 10);
+
+    public static Dictionary<string, string> GetNamedGroups(Regex regex, string input)
     {
-        public static Dictionary<string, string> GetNamedGroups(Regex regex, string input)
+        var namedGroupsDictionary = new Dictionary<string, string>();
+
+        GroupCollection groups = regex.Match(input).Groups;
+        foreach (string groupName in regex.GetGroupNames())
         {
-            var namedGroupsDictionary = new Dictionary<string, string>();
-
-            GroupCollection groups = regex.Match(input).Groups;
-            foreach (string groupName in regex.GetGroupNames())
+            if (groups[groupName].Captures.Count > 0)
             {
-                if (groups[groupName].Captures.Count > 0)
-                {
-                    namedGroupsDictionary.Add(groupName, groups[groupName].Value);
-                }
+                namedGroupsDictionary.Add(groupName, groups[groupName].Value);
             }
+        }
 
-            return namedGroupsDictionary;
+        return namedGroupsDictionary;
+    }
+
+    public static (bool IsValid, bool Result) MatchRegex(string pattern, string input, bool useRegexExtended = true)
+    {
+        if (string.IsNullOrEmpty(pattern))
+        {
+            return (false, false);
+        }
+
+        try
+        {
+            if (useRegexExtended)
+            {
+                var r = new RegexExtended(pattern, RegexOptions.None, RegexTimeOut);
+                return (true, r.IsMatch(input));
+            }
+            else
+            {
+                var r = new Regex(pattern, RegexOptions.None, RegexTimeOut);
+                return (true, r.IsMatch(input));
+            }
+        }
+        catch
+        {
+            return (false, false);
         }
     }
-}
+}

src/WireMock.Net/WireMock.Net.csproj

@@ -127,7 +127,7 @@
     </ItemGroup>
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
-        <PackageReference Include="Scriban.Signed" Version="3.3.2" />
+        <PackageReference Include="Scriban.Signed" Version="5.5.0" />
         <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
         <PackageReference Include="Nullable" Version="1.3.0" />
 
@@ -137,7 +137,7 @@
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' ">
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
-        <PackageReference Include="Scriban.Signed" Version="3.3.2" />
+        <PackageReference Include="Scriban.Signed" Version="5.5.0" />
     </ItemGroup>
 
     <ItemGroup>

test/WireMock.Net.Tests/Matchers/JsonMatcherTests.cs

@@ -1,299 +1,356 @@
-using System;
+using System;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
 using NFluent;
 using WireMock.Matchers;
 using Xunit;
 
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers;
+
+public class JsonMatcherTests
 {
-    public class JsonMatcherTests
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum EnumWithJsonConverter
     {
-        [Fact]
-        public void JsonMatcher_GetName()
+        Type1
+    }
+
+    public enum NormalEnum
+    {
+        Abc
+    }
+
+    public class Test1
+    {
+        public NormalEnum NormalEnum { get; set; }
+    }
+
+    public class Test2
+    {
+        public EnumWithJsonConverter EnumWithJsonConverter { get; set; }
+    }
+
+    [Fact]
+    public void JsonMatcher_GetName()
+    {
+        // Assign
+        var matcher = new JsonMatcher("{}");
+
+        // Act
+        string name = matcher.Name;
+
+        // Assert
+        Check.That(name).Equals("JsonMatcher");
+    }
+
+    [Fact]
+    public void JsonMatcher_GetValue()
+    {
+        // Assign
+        var matcher = new JsonMatcher("{}");
+
+        // Act
+        object value = matcher.Value;
+
+        // Assert
+        Check.That(value).Equals("{}");
+    }
+
+    [Fact]
+    public void JsonMatcher_WithInvalidStringValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_WithInvalidObjectValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher("");
+
+        // Act
+        double match = matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher("", false, true);
+
+        // Act
+        Action action = () => matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_ByteArray()
+    {
+        // Assign
+        var bytes = new byte[0];
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(bytes);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_NullString()
+    {
+        // Assign
+        string? s = null;
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(s);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_NullObject()
+    {
+        // Assign
+        object? o = null;
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(o);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_JArray()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new[] { "x", "y" });
+
+        // Act 
+        var jArray = new JArray
         {
-            // Assign
-            var matcher = new JsonMatcher("{}");
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
 
-            // Act
-            string name = matcher.Name;
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert
-            Check.That(name).Equals("JsonMatcher");
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObject()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
 
-        [Fact]
-        public void JsonMatcher_GetValue()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("{}");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            object value = matcher.Value;
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert
-            Check.That(value).Equals("{}");
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { id = 1, Name = "test" }, true);
 
-        [Fact]
-        public void JsonMatcher_WithInvalidStringValue_Should_ThrowException()
+        // Act 
+        var jObject = new JObject
         {
-            // Act
-            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+            { "Id", new JValue(1) },
+            { "NaMe", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-        [Fact]
-        public void JsonMatcher_WithInvalidObjectValue_Should_ThrowException()
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "TESt" }, true);
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_JArrayAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("[ \"x\", \"y\" ]");
+
+        // Act 
+        var jArray = new JArray
         {
-            // Act
-            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
 
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-        [Fact]
-        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            double match = matcher.IsMatch(new MemoryStream());
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
 
-        [Fact]
-        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("", false, true);
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            Action action = () => matcher.IsMatch(new MemoryStream());
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            action.Should().Throw<JsonException>();
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectAsString_RejectOnMatch()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
-        [Fact]
-        public void JsonMatcher_IsMatch_ByteArray()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var bytes = new byte[0];
-            var matcher = new JsonMatcher("");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(bytes);
+        // Assert 
+        Assert.Equal(0.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
 
-        [Fact]
-        public void JsonMatcher_IsMatch_NullString()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            string s = null;
-            var matcher = new JsonMatcher("");
+            { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(s);
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_NormalEnum()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new Test1 { NormalEnum = NormalEnum.Abc});
 
-        [Fact]
-        public void JsonMatcher_IsMatch_NullObject()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            object o = null;
-            var matcher = new JsonMatcher("");
+            { "NormalEnum", new JValue(0) }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(o);
+        // Assert 
+        match.Should().Be(1.0);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_EnumWithJsonConverter()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new Test2 { EnumWithJsonConverter = EnumWithJsonConverter.Type1 });
 
-        [Fact]
-        public void JsonMatcher_IsMatch_JArray()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign 
-            var matcher = new JsonMatcher(new[] { "x", "y" });
+            { "EnumWithJsonConverter", new JValue("Type1") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObject()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { id = 1, Name = "test" }, true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "NaMe", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "TESt" }, true);
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JArrayAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("[ \"x\", \"y\" ]");
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectAsString_RejectOnMatch()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(0.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
+        // Assert 
+        match.Should().Be(1.0);
     }
 }

test/WireMock.Net.Tests/Matchers/JsonPartialMatcherTests.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
@@ -42,6 +41,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_WithInvalidStringValue_Should_ThrowException()
         {
             // Act
+            // ReSharper disable once ObjectCreationAsStatement
             Action action = () => new JsonPartialMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
 
             // Assert
@@ -52,6 +52,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_WithInvalidObjectValue_Should_ThrowException()
         {
             // Act
+            // ReSharper disable once ObjectCreationAsStatement
             Action action = () => new JsonPartialMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
 
             // Assert
@@ -102,7 +103,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_IsMatch_NullString()
         {
             // Assign
-            string s = null;
+            string? s = null;
             var matcher = new JsonPartialMatcher("");
 
             // Act 
@@ -116,7 +117,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_IsMatch_NullObject()
         {
             // Assign
-            object o = null;
+            object? o = null;
             var matcher = new JsonPartialMatcher("");
 
             // Act 
@@ -151,17 +152,53 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "Test" });
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
         }
 
+        [Fact]
+        public void JsonPartialMatcher_IsMatch_WithRegexTrue()
+        {
+            // Assign 
+            var matcher = new JsonPartialMatcher(new { Id = "^\\d+$", Name = "Test" }, false, false, true);
+
+            // Act 
+            var jObject = new JObject
+            {
+                { "Id", new JValue(1) },
+                { "Name", new JValue("Test") }
+            };
+            double match = matcher.IsMatch(jObject);
+
+            // Assert 
+            Assert.Equal(1.0, match);
+        }
+
+        [Fact]
+        public void JsonPartialMatcher_IsMatch_WithRegexFalse()
+        {
+            // Assign 
+            var matcher = new JsonPartialMatcher(new { Id = "^\\d+$", Name = "Test" });
+
+            // Act 
+            var jObject = new JObject
+            {
+                { "Id", new JValue(1) },
+                { "Name", new JValue("Test") }
+            };
+            double match = matcher.IsMatch(jObject);
+
+            // Assert 
+            Assert.Equal(0.0, match);
+        }
+
         [Fact]
         public void JsonPartialMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
         {
@@ -169,12 +206,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { id = 1, Name = "test" }, true);
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "NaMe", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -187,8 +224,8 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "Test" });
 
             // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
+            var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -201,8 +238,8 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "TESt" }, true);
 
             // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
+            var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -233,12 +270,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -251,12 +288,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -269,12 +306,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(0.0, match);
@@ -287,11 +324,11 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);

test/WireMock.Net.Tests/Matchers/JsonPartialWildcardMatcherTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
@@ -8,393 +7,394 @@ using NFluent;
 using WireMock.Matchers;
 using Xunit;
 
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers;
+
+public class JsonPartialWildcardMatcherTests
 {
-    public class JsonPartialWildcardMatcherTests
+    [Fact]
+    public void JsonPartialWildcardMatcher_GetName()
     {
-        [Fact]
-        public void JsonPartialWildcardMatcher_GetName()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("{}");
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("{}");
 
-            // Act
-            string name = matcher.Name;
+        // Act
+        string name = matcher.Name;
 
-            // Assert
-            Check.That(name).Equals("JsonPartialWildcardMatcher");
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_GetValue()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("{}");
-
-            // Act
-            object value = matcher.Value;
-
-            // Assert
-            Check.That(value).Equals("{}");
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_WithInvalidStringValue_Should_ThrowException()
-        {
-            // Act
-            Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
-
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_WithInvalidObjectValue_Should_ThrowException()
-        {
-            // Act
-            Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
-
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act
-            double match = matcher.IsMatch(new MemoryStream());
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("", false, true);
-
-            // Act
-            Action action = () => matcher.IsMatch(new MemoryStream());
-
-            // Assert 
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_ByteArray()
-        {
-            // Assign
-            var bytes = new byte[0];
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(bytes);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_NullString()
-        {
-            // Assign
-            string s = null;
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(s);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_NullObject()
-        {
-            // Assign
-            object o = null;
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(o);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JArray()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new[] { "x", "y" });
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObject()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { id = 1, Name = "test" }, true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "NaMe", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "TESt" }, true);
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JArrayAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("[ \"x\", \"y\" ]");
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString_RejectOnMatch()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(0.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{\"test\":\"abc\"}", "{\"test\":\"abc\",\"other\":\"xyz\"}")]
-        [InlineData("\"test\"", "\"test\"")]
-        [InlineData("123", "123")]
-        [InlineData("[\"test\"]", "[\"test\"]")]
-        [InlineData("[\"test\"]", "[\"test\", \"other\"]")]
-        [InlineData("[123]", "[123]")]
-        [InlineData("[123]", "[123, 456]")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\",\"other\":123}")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\"}")]
-        [InlineData("{\"test\":{\"nested\":\"value\"}}", "{\"test\":{\"nested\":\"value\"}}")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInput_IsValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{\"test\":\"*\"}", "{\"test\":\"xxx\",\"other\":\"xyz\"}")]
-        [InlineData("\"t*t\"", "\"test\"")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInputWithWildcard_IsValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            match.Should().Be(1.0);
-        }
-
-        [Theory]
-        [InlineData("\"test\"", null)]
-        [InlineData("\"test1\"", "\"test2\"")]
-        [InlineData("123", "1234")]
-        [InlineData("[\"test\"]", "[\"test1\"]")]
-        [InlineData("[\"test\"]", "[\"test1\", \"test2\"]")]
-        [InlineData("[123]", "[1234]")]
-        [InlineData("{}", "\"test\"")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value2\"}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
-        [InlineData("{\"test\":{\"test1\":\"value\"}}", "{\"test\":{\"test1\":\"value1\"}}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInputWithInvalidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(0.0, match);
-        }
-
-        [Theory]
-        [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":123}}")]
-        [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[123, 456]}}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value\"}}")]
-        [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value\"}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value\"}}]")]
-        [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value\"}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":456}}")]
-        [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[1, 2]}}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
-        [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value1\"}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
-        [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value1\"}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathInvalidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(0.0, match);
-        }
+        // Assert
+        Check.That(name).Equals("JsonPartialWildcardMatcher");
     }
-}
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_GetValue()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("{}");
+
+        // Act
+        object value = matcher.Value;
+
+        // Assert
+        Check.That(value).Equals("{}");
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_WithInvalidStringValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_WithInvalidObjectValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act
+        double match = matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("", false, true);
+
+        // Act
+        Action action = () => matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_ByteArray()
+    {
+        // Assign
+        var bytes = new byte[0];
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(bytes);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_NullString()
+    {
+        // Assign
+        string? s = null;
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(s);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_NullObject()
+    {
+        // Assign
+        object? o = null;
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(o);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JArray()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new[] { "x", "y" });
+
+        // Act 
+        var jArray = new JArray
+        {
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObject()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { id = 1, Name = "test" }, true);
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "NaMe", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "TESt" }, true);
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JArrayAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("[ \"x\", \"y\" ]");
+
+        // Act 
+        var jArray = new JArray
+        {
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString_RejectOnMatch()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(0.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{\"test\":\"abc\"}", "{\"test\":\"abc\",\"other\":\"xyz\"}")]
+    [InlineData("\"test\"", "\"test\"")]
+    [InlineData("123", "123")]
+    [InlineData("[\"test\"]", "[\"test\"]")]
+    [InlineData("[\"test\"]", "[\"test\", \"other\"]")]
+    [InlineData("[123]", "[123]")]
+    [InlineData("[123]", "[123, 456]")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\",\"other\":123}")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\"}")]
+    [InlineData("{\"test\":{\"nested\":\"value\"}}", "{\"test\":{\"nested\":\"value\"}}")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInput_IsValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{\"test\":\"*\"}", "{\"test\":\"xxx\",\"other\":\"xyz\"}")]
+    [InlineData("\"t*t\"", "\"test\"")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInputWithWildcard_IsValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        match.Should().Be(1.0);
+    }
+
+    [Theory]
+    [InlineData("\"test\"", null)]
+    [InlineData("\"test1\"", "\"test2\"")]
+    [InlineData("123", "1234")]
+    [InlineData("[\"test\"]", "[\"test1\"]")]
+    [InlineData("[\"test\"]", "[\"test1\", \"test2\"]")]
+    [InlineData("[123]", "[1234]")]
+    [InlineData("{}", "\"test\"")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value2\"}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
+    [InlineData("{\"test\":{\"test1\":\"value\"}}", "{\"test\":{\"test1\":\"value1\"}}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInputWithInvalidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(0.0, match);
+    }
+
+    [Theory]
+    [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":123}}")]
+    [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[123, 456]}}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value\"}}")]
+    [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value\"}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value\"}}]")]
+    [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value\"}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":456}}")]
+    [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[1, 2]}}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
+    [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value1\"}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
+    [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value1\"}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathInvalidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(0.0, match);
+    }
+}

test/WireMock.Net.Tests/RequestMatchers/RequestMessageHeaderMatcherTests.cs

@@ -5,165 +5,164 @@ using WireMock.Matchers.Request;
 using WireMock.Models;
 using Xunit;
 
-namespace WireMock.Net.Tests.RequestMatchers
+namespace WireMock.Net.Tests.RequestMatchers;
+
+public class RequestMessageHeaderMatcherTests
 {
-    public class RequestMessageHeaderMatcherTests
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotExists()
     {
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotExists()
-        {
-            // Assign
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
+        // Assign
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotExists()
-        {
-            // Assign
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotExists()
+    {
+        // Assign
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotMatchPattern()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "no-match", "123", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotMatchPattern()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "no-match", "123", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotMatchPattern()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "no-match", "123", true);
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotMatchPattern()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "no-match", "123", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact(Skip = "does not work anymore since 'and'/'or'/'average'")]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
+    [Fact(Skip = "does not work anymore since 'and'/'or'/'average'")]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_IStringMatcher_Match()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, MatchOperator.Or, "h", false, new ExactMatcher("x"));
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_IStringMatcher_Match()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, MatchOperator.Or, "h", false, new ExactMatcher("x"));
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_Func_Match()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(x => x.ContainsKey("h"));
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_Func_Match()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(x => x.ContainsKey("h"));
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderValue()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "teST" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "test", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderValue()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "teST" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "test", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderName()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "teST", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "TEST", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderName()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "teST", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "TEST", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
     }
 }

test/WireMock.Net.Tests/RequestMessageTests.cs

@@ -1,107 +1,106 @@
-using NFluent;
+using NFluent;
 using WireMock.Models;
 using WireMock.Util;
 using Xunit;
 
-namespace WireMock.Net.Tests
+namespace WireMock.Net.Tests;
+
+public class RequestMessageTests
 {
-    public class RequestMessageTests
+    private const string ClientIp = "::1";
+
+    [Fact]
+    public void RequestMessage_Method_Should_BeSame()
     {
-        private const string ClientIp = "::1";
+        // given
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "posT", ClientIp);
 
-        [Fact]
-        public void RequestMessage_Method_Should_BeSame()
-        {
-            // given
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "posT", ClientIp);
+        // then
+        Check.That(request.Method).IsEqualTo("posT");
+    }
 
-            // then
-            Check.That(request.Method).IsEqualTo("posT");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_NoKeys()
+    {
+        // given
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_NoKeys()
-        {
-            // given
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp);
+        // then
+        Check.That(request.GetParameter("not_there")).IsNull();
+    }
 
-            // then
-            Check.That(request.GetParameter("not_there")).IsNull();
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_SingleValue()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_SingleValue()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("foo")).ContainsExactly("bar");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("foo")).ContainsExactly("bar");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_SingleValue_WithIgnoreCase()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_SingleValue_WithIgnoreCase()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("FoO", true)).ContainsExactly("bar");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("FoO", true)).ContainsExactly("bar");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_MultipleKeys_MultipleValues()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1&key=2"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_MultipleKeys_MultipleValues()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1&key=2"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_MultipleValuesCommaSeparated()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2,3"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_MultipleValuesCommaSeparated()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2,3"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+        Check.That(request.GetParameter("key")).Contains("3");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-            Check.That(request.GetParameter("key")).Contains("3");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_MultipleValues()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2&foo=bar&key=3"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_MultipleValues()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2&foo=bar&key=3"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+        Check.That(request.GetParameter("key")).Contains("3");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-            Check.That(request.GetParameter("key")).Contains("3");
-        }
+    [Fact]
+    public void RequestMessage_Constructor1_PathSegments()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_Constructor1_PathSegments()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp);
+        // Assert
+        Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+    }
 
-            // Assert
-            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
-        }
+    [Fact]
+    public void RequestMessage_Constructor2_PathSegments()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
 
-        [Fact]
-        public void RequestMessage_Constructor2_PathSegments()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
-
-            // Assert
-            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
-        }
+        // Assert
+        Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
     }
 }

test/WireMock.Net.Tests/Serialization/CustomPathParamMatcher.cs

@@ -41,7 +41,7 @@ public class CustomPathParamMatcher : IStringMatcher
         MatchOperator = matchOperator;
     }
 
-    public double IsMatch(string input)
+    public double IsMatch(string? input)
     {
         var inputParts = GetPathParts(input);
         if (inputParts.Length != _pathParts.Length)
@@ -97,8 +97,13 @@ public class CustomPathParamMatcher : IStringMatcher
 
     public MatchOperator MatchOperator { get; }
 
-    private static string[] GetPathParts(string path)
+    private static string[] GetPathParts(string? path)
     {
+        if (path is null)
+        {
+            return new string[0];
+        }
+
         var hashMarkIndex = path.IndexOf('#');
         if (hashMarkIndex != -1)
         {

test/WireMock.Net.Tests/Serialization/MatcherMapperTests.cs

@@ -10,399 +10,402 @@ using WireMock.Serialization;
 using WireMock.Settings;
 using Xunit;
 
-namespace WireMock.Net.Tests.Serialization
+namespace WireMock.Net.Tests.Serialization;
+
+public class MatcherMapperTests
 {
-    public class MatcherMapperTests
+    private readonly WireMockServerSettings _settings = new();
+    private readonly MatcherMapper _sut;
+
+    public MatcherMapperTests()
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
-        private readonly MatcherMapper _sut;
-
-        public MatcherMapperTests()
-        {
-            _sut = new MatcherMapper(_settings);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatcher_Null()
-        {
-            // Act
-            var model = _sut.Map((IMatcher)null);
-
-            // Assert
-            model.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatchers_Null()
-        {
-            // Act
-            var model = _sut.Map((IMatcher[])null);
-
-            // Assert
-            model.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatchers()
-        {
-            // Assign
-            var matcherMock1 = new Mock<IStringMatcher>();
-            var matcherMock2 = new Mock<IStringMatcher>();
-
-            // Act
-            var models = _sut.Map(new[] { matcherMock1.Object, matcherMock2.Object });
-
-            // Assert
-            models.Should().HaveCount(2);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IStringMatcher()
-        {
-            // Assign
-            var matcherMock = new Mock<IStringMatcher>();
-            matcherMock.Setup(m => m.Name).Returns("test");
-            matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { "p1", "p2" });
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeNull();
-            model.Name.Should().Be("test");
-            model.Pattern.Should().BeNull();
-            model.Patterns.Should().HaveCount(2)
-                .And.Contain("p1")
-                .And.Contain("p2");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IStringMatcher_With_PatternAsFile()
-        {
-            // Arrange
-            var pattern = new StringPattern { Pattern = "p", PatternAsFile = "pf" };
-
-            var matcherMock = new Mock<IStringMatcher>();
-            matcherMock.Setup(m => m.Name).Returns("test");
-            matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { pattern });
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeNull();
-            model.Name.Should().Be("test");
-            model.Pattern.Should().Be("p");
-            model.Patterns.Should().BeNull();
-            model.PatternAsFile.Should().Be("pf");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IIgnoreCaseMatcher()
-        {
-            // Assign
-            var matcherMock = new Mock<IIgnoreCaseMatcher>();
-            matcherMock.Setup(m => m.IgnoreCase).Returns(true);
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeTrue();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_Null()
-        {
-            // Act
-            var result = _sut.Map((MatcherModel)null);
-
-            // Assert
-            result.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_Exception()
-        {
-            // Assign
-            var model = new MatcherModel { Name = "test" };
-
-            // Act and Assert
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Pattern()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "LinqMatcher",
-                Pattern = "p"
-            };
-
-            // Act
-            var matcher = (LinqMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.GetPatterns().Should().Contain("p");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Patterns()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "LinqMatcher",
-                Patterns = new[] { "p1", "p2" }
-            };
-
-            // Act
-            var matcher = (LinqMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.GetPatterns().Should().Contain("p1", "p2");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_String()
-        {
-            // Assign
-            var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_String()
-        {
-            // Assign
-            var pattern = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
-            var patterns = new[] { pattern };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_String()
-        {
-            // Assign
-            var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var pattern2 = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_Object()
-        {
-            // Assign
-            var pattern = new { AccountIds = new[] { 1, 2, 3 } };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_Object()
-        {
-            // Assign
-            object pattern = new { post1 = "value1", post2 = "value2" };
-            var patterns = new[] { pattern };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_Object()
-        {
-            // Assign
-            object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
-            object pattern2 = new { post1 = "value1", post2 = "value2" };
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_String()
-        {
-            // Assign
-            var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_String()
-        {
-            // Assign
-            var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var pattern2 = "{ \"X\": \"x\" }";
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = patterns
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_Object()
-        {
-            // Assign
-            var pattern = new { AccountIds = new[] { 1, 2, 3 } };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_Object()
-        {
-            // Assign
-            object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
-            object pattern2 = new { X = "x" };
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_StringPattern_With_PatternAsFile()
-        {
-            // Assign
-            var pattern = new StringPattern { Pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }", PatternAsFile = "pf" };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialWilcardMatcher_Patterns_As_Object()
-        {
-            // Assign
-            object pattern = new { X = "*" };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialWildcardMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialWildcardMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
+        _sut = new MatcherMapper(_settings);
     }
-}
+
+    [Fact]
+    public void MatcherMapper_Map_IMatcher_Null()
+    {
+        // Act
+        var model = _sut.Map((IMatcher?)null);
+
+        // Assert
+        model.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IMatchers_Null()
+    {
+        // Act
+        var model = _sut.Map((IMatcher[]?)null);
+
+        // Assert
+        model.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IMatchers()
+    {
+        // Assign
+        var matcherMock1 = new Mock<IStringMatcher>();
+        var matcherMock2 = new Mock<IStringMatcher>();
+
+        // Act
+        var models = _sut.Map(new[] { matcherMock1.Object, matcherMock2.Object });
+
+        // Assert
+        models.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IStringMatcher()
+    {
+        // Assign
+        var matcherMock = new Mock<IStringMatcher>();
+        matcherMock.Setup(m => m.Name).Returns("test");
+        matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { "p1", "p2" });
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeNull();
+        model.Name.Should().Be("test");
+        model.Pattern.Should().BeNull();
+        model.Patterns.Should().HaveCount(2)
+            .And.Contain("p1")
+            .And.Contain("p2");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IStringMatcher_With_PatternAsFile()
+    {
+        // Arrange
+        var pattern = new StringPattern { Pattern = "p", PatternAsFile = "pf" };
+
+        var matcherMock = new Mock<IStringMatcher>();
+        matcherMock.Setup(m => m.Name).Returns("test");
+        matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { pattern });
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeNull();
+        model.Name.Should().Be("test");
+        model.Pattern.Should().Be("p");
+        model.Patterns.Should().BeNull();
+        model.PatternAsFile.Should().Be("pf");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IIgnoreCaseMatcher()
+    {
+        // Assign
+        var matcherMock = new Mock<IIgnoreCaseMatcher>();
+        matcherMock.Setup(m => m.IgnoreCase).Returns(true);
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeTrue();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_Null()
+    {
+        // Act
+        var result = _sut.Map((MatcherModel?)null);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_Exception()
+    {
+        // Assign
+        var model = new MatcherModel { Name = "test" };
+
+        // Act and Assert
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_LinqMatcher_Pattern()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "LinqMatcher",
+            Pattern = "p"
+        };
+
+        // Act
+        var matcher = (LinqMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.GetPatterns().Should().Contain("p");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_LinqMatcher_Patterns()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "LinqMatcher",
+            Patterns = new[] { "p1", "p2" }
+        };
+
+        // Act
+        var matcher = (LinqMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.GetPatterns().Should().Contain("p1", "p2");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_String()
+    {
+        // Assign
+        var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_String()
+    {
+        // Assign
+        var pattern = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
+        var patterns = new[] { pattern };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_String()
+    {
+        // Assign
+        var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var pattern2 = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_Object()
+    {
+        // Assign
+        var pattern = new { AccountIds = new[] { 1, 2, 3 } };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_Object()
+    {
+        // Assign
+        object pattern = new { post1 = "value1", post2 = "value2" };
+        var patterns = new[] { pattern };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_Object()
+    {
+        // Assign
+        object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
+        object pattern2 = new { post1 = "value1", post2 = "value2" };
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_String()
+    {
+        // Assign
+        var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_String()
+    {
+        // Assign
+        var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var pattern2 = "{ \"X\": \"x\" }";
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = patterns
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_Object()
+    {
+        // Assign
+        var pattern = new { AccountIds = new[] { 1, 2, 3 } };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_Object()
+    {
+        // Assign
+        object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
+        object pattern2 = new { X = "x" };
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_StringPattern_With_PatternAsFile()
+    {
+        // Assign
+        var pattern = new StringPattern { Pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }", PatternAsFile = "pf" };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern,
+            Regex = true
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+        matcher.Regex.Should().BeTrue();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialWildcardMatcher_Patterns_As_Object()
+    {
+        // Assign
+        object pattern = new { X = "*" };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialWildcardMatcher",
+            Pattern = pattern,
+            Regex = false
+        };
+
+        // Act
+        var matcher = (JsonPartialWildcardMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+        matcher.Regex.Should().BeFalse();
+    }
+}

test/WireMock.Net.Tests/Serialization/MatcherModelMapperTests.cs

@@ -14,378 +14,427 @@ using WireMock.Serialization;
 using WireMock.Settings;
 using Xunit;
 
-namespace WireMock.Net.Tests.Serialization
+namespace WireMock.Net.Tests.Serialization;
+
+public class MatcherModelMapperTests
 {
-    public class MatcherModelMapperTests
+    private readonly WireMockServerSettings _settings = new();
+
+    private readonly MatcherMapper _sut;
+
+    public MatcherModelMapperTests()
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+        _sut = new MatcherMapper(_settings);
+    }
 
-        private readonly MatcherMapper _sut;
-
-        public MatcherModelMapperTests()
+    [Fact]
+    public void MatcherModelMapper_Map_CSharpCodeMatcher()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            _sut = new MatcherMapper(_settings);
-        }
+            Name = "CSharpCodeMatcher",
+            Patterns = new[] { "return it == \"x\";" }
+        };
+        var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
 
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher()
+        // Act 1
+        var matcher1 = (ICSharpCodeMatcher)sut.Map(model)!;
+
+        // Assert 1
+        matcher1.Should().NotBeNull();
+        matcher1.IsMatch("x").Should().Be(1.0d);
+
+        // Act 2
+        var matcher2 = (ICSharpCodeMatcher)sut.Map(model)!;
+
+        // Assert 2
+        matcher2.Should().NotBeNull();
+        matcher2.IsMatch("x").Should().Be(1.0d);
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "return it == \"x\";" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
+            Name = "CSharpCodeMatcher",
+            Patterns = new[] { "x" }
+        };
+        var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
 
-            // Act 1
-            var matcher1 = (ICSharpCodeMatcher)sut.Map(model);
+        // Act
+        Action action = () => sut.Map(model);
 
-            // Assert 1
-            matcher1.Should().NotBeNull();
-            matcher1.IsMatch("x").Should().Be(1.0d);
+        // Assert
+        action.Should().Throw<NotSupportedException>();
+    }
 
-            // Act 2
-            var matcher2 = (ICSharpCodeMatcher)sut.Map(model);
+    [Fact]
+    public void MatcherModelMapper_Map_Null()
+    {
+        // Act
+        IMatcher matcher = _sut.Map((MatcherModel?)null)!;
 
-            // Assert 2
-            matcher2.Should().NotBeNull();
-            matcher2.IsMatch("x").Should().Be(1.0d);
-        }
+        // Assert
+        Check.That(matcher).IsNull();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactMatcher_Pattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "x" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
+            Name = "ExactMatcher",
+            Patterns = new[] { "x" }
+        };
 
-            // Act
-            Action action = () => sut.Map(model);
+        // Act
+        var matcher = (ExactMatcher)_sut.Map(model)!;
 
-            // Assert
-            action.Should().Throw<NotSupportedException>();
-        }
+        // Assert
+        matcher.GetPatterns().Should().ContainSingle("x");
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_Null()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactMatcher_Patterns()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Act
-            IMatcher matcher = _sut.Map((MatcherModel)null);
+            Name = "ExactMatcher",
+            Patterns = new[] { "x", "y" }
+        };
 
-            // Assert
-            Check.That(matcher).IsNull();
-        }
+        // Act
+        var matcher = (ExactMatcher)_sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Pattern()
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_JsonPartialMatcher_RegexFalse()
+    {
+        // Assign
+        var pattern = "{ \"x\": 1 }";
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x" }
-            };
+            Name = "JsonPartialMatcher",
+            Regex = false,
+            Pattern = pattern
+        };
 
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
 
-            // Assert
-            matcher.GetPatterns().Should().ContainSingle("x");
-            matcher.ThrowException.Should().BeFalse();
-        }
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.IgnoreCase.Should().BeFalse();
+        matcher.Value.Should().Be(pattern);
+        matcher.Regex.Should().BeFalse();
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Patterns()
+    [Fact]
+    public void MatcherModelMapper_Map_JsonPartialMatcher_RegexTrue()
+    {
+        // Assign
+        var pattern = "{ \"x\": 1 }";
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x", "y" }
-            };
+            Name = "JsonPartialMatcher",
+            Regex = true,
+            Pattern = pattern
+        };
 
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-        }
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.IgnoreCase.Should().BeFalse();
+        matcher.Value.Should().Be(pattern);
+        matcher.Regex.Should().BeTrue();
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Theory]
-        [InlineData(nameof(LinqMatcher))]
-        [InlineData(nameof(ExactMatcher))]
-        [InlineData(nameof(ExactObjectMatcher))]
-        [InlineData(nameof(RegexMatcher))]
-        [InlineData(nameof(JsonMatcher))]
-        [InlineData(nameof(JsonPathMatcher))]
-        [InlineData(nameof(JmesPathMatcher))]
-        [InlineData(nameof(XPathMatcher))]
-        [InlineData(nameof(WildcardMatcher))]
-        [InlineData(nameof(ContentTypeMatcher))]
-        [InlineData(nameof(SimMetricsMatcher))]
-        public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
+    [Theory]
+    [InlineData(nameof(LinqMatcher))]
+    [InlineData(nameof(ExactMatcher))]
+    [InlineData(nameof(ExactObjectMatcher))]
+    [InlineData(nameof(RegexMatcher))]
+    [InlineData(nameof(JsonMatcher))]
+    [InlineData(nameof(JsonPartialMatcher))]
+    [InlineData(nameof(JsonPartialWildcardMatcher))]
+    [InlineData(nameof(JsonPathMatcher))]
+    [InlineData(nameof(JmesPathMatcher))]
+    [InlineData(nameof(XPathMatcher))]
+    [InlineData(nameof(WildcardMatcher))]
+    [InlineData(nameof(ContentTypeMatcher))]
+    [InlineData(nameof(SimMetricsMatcher))]
+    public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
+    {
+        // Assign
+        var settings = new WireMockServerSettings
         {
-            // Assign
-            var settings = new WireMockServerSettings
-            {
-                ThrowExceptionWhenMatcherFails = true
-            };
-            var sut = new MatcherMapper(settings);
-            var model = new MatcherModel
-            {
-                Name = name,
-                Patterns = new[] { "" }
-            };
-
-            // Act
-            var matcher = sut.Map(model);
-
-            // Assert
-            matcher.ThrowException.Should().BeTrue();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
+            ThrowExceptionWhenMatcherFails = true
+        };
+        var sut = new MatcherMapper(settings);
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "c3RlZg==" }
-            };
+            Name = name,
+            Patterns = new[] { "" }
+        };
 
-            // Act
-            var matcher = (ExactObjectMatcher)_sut.Map(model);
+        // Act
+        var matcher = sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
-        }
+        // Assert
+        matcher.Should().NotBeNull();
+        matcher.ThrowException.Should().BeTrue();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "_" }
-            };
+            Name = "ExactObjectMatcher",
+            Patterns = new object[] { "c3RlZg==" }
+        };
 
-            // Act & Assert
-            Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
-        }
+        // Act
+        var matcher = (ExactObjectMatcher)_sut.Map(model)!;
 
-        [Theory]
-        [InlineData(MatchOperator.Or, 1.0d)]
-        [InlineData(MatchOperator.And, 0.0d)]
-        [InlineData(MatchOperator.Average, 0.5d)]
-        public void MatcherModelMapper_Map_RegexMatcher(MatchOperator matchOperator, double expected)
+        // Assert
+        Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "RegexMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true,
-                MatchOperator = matchOperator.ToString()
-            };
+            Name = "ExactObjectMatcher",
+            Patterns = new object[] { "_" }
+        };
 
-            // Act
-            var matcher = (RegexMatcher)_sut.Map(model)!;
+        // Act & Assert
+        Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
+    }
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
-        }
-
-        [Theory]
-        [InlineData(MatchOperator.Or, 1.0d)]
-        [InlineData(MatchOperator.And, 0.0d)]
-        [InlineData(MatchOperator.Average, 0.5d)]
-        public void MatcherModelMapper_Map_WildcardMatcher_IgnoreCase(MatchOperator matchOperator, double expected)
+    [Theory]
+    [InlineData(MatchOperator.Or, 1.0d)]
+    [InlineData(MatchOperator.And, 0.0d)]
+    [InlineData(MatchOperator.Average, 0.5d)]
+    public void MatcherModelMapper_Map_RegexMatcher(MatchOperator matchOperator, double expected)
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "WildcardMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true,
-                MatchOperator = matchOperator.ToString()
-            };
+            Name = "RegexMatcher",
+            Patterns = new[] { "x", "y" },
+            IgnoreCase = true,
+            MatchOperator = matchOperator.ToString()
+        };
 
-            // Act
-            var matcher = (WildcardMatcher)_sut.Map(model)!;
+        // Act
+        var matcher = (RegexMatcher)_sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
-        }
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+        Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_WildcardMatcher_With_PatternAsFile()
+    [Theory]
+    [InlineData(MatchOperator.Or, 1.0d)]
+    [InlineData(MatchOperator.And, 0.0d)]
+    [InlineData(MatchOperator.Average, 0.5d)]
+    public void MatcherModelMapper_Map_WildcardMatcher_IgnoreCase(MatchOperator matchOperator, double expected)
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var file = "c:\\test.txt";
-            var fileContent = "c";
-            var stringPattern = new StringPattern
-            {
-                Pattern = fileContent,
-                PatternAsFile = file
-            };
-            var fileSystemHandleMock = new Mock<IFileSystemHandler>();
-            fileSystemHandleMock.Setup(f => f.ReadFileAsString(file)).Returns(fileContent);
+            Name = "WildcardMatcher",
+            Patterns = new[] { "x", "y" },
+            IgnoreCase = true,
+            MatchOperator = matchOperator.ToString()
+        };
 
-            var model = new MatcherModel
-            {
-                Name = "WildcardMatcher",
-                PatternAsFile = file
-            };
+        // Act
+        var matcher = (WildcardMatcher)_sut.Map(model)!;
 
-            var settings = new WireMockServerSettings
-            {
-                FileSystemHandler = fileSystemHandleMock.Object
-            };
-            var sut = new MatcherMapper(settings);
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+        Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
+    }
 
-            // Act
-            var matcher = (WildcardMatcher)sut.Map(model);
-
-            // Assert
-            matcher.GetPatterns().Should().HaveCount(1).And.Contain(new AnyOf<string, StringPattern>(stringPattern));
-            matcher.IsMatch("c").Should().Be(1.0d);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher()
+    [Fact]
+    public void MatcherModelMapper_Map_WildcardMatcher_With_PatternAsFile()
+    {
+        // Arrange
+        var file = "c:\\test.txt";
+        var fileContent = "c";
+        var stringPattern = new StringPattern
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher",
-                Pattern = "x"
-            };
+            Pattern = fileContent,
+            PatternAsFile = file
+        };
+        var fileSystemHandleMock = new Mock<IFileSystemHandler>();
+        fileSystemHandleMock.Setup(f => f.ReadFileAsString(file)).Returns(fileContent);
 
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.BlockDistance",
-                Pattern = "x"
-            };
+            Name = "WildcardMatcher",
+            PatternAsFile = file
+        };
 
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
+        var settings = new WireMockServerSettings
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "error",
-                Pattern = "x"
-            };
+            FileSystemHandler = fileSystemHandleMock.Object
+        };
+        var sut = new MatcherMapper(settings);
 
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
+        // Act
+        var matcher = (WildcardMatcher)sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
+        // Assert
+        matcher.GetPatterns().Should().HaveCount(1).And.Contain(new AnyOf<string, StringPattern>(stringPattern));
+        matcher.IsMatch("c").Should().Be(1.0d);
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.error",
-                Pattern = "x"
-            };
+            Name = "SimMetricsMatcher",
+            Pattern = "x"
+        };
 
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
+        // Act
+        var matcher = (SimMetricsMatcher)_sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_MatcherModelToCustomMatcher()
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x");
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var patternModel = new CustomPathParamMatcherModel("/customer/{customerId}/document/{documentId}",
-                new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
-            var model = new MatcherModel
-            {
-                Name = nameof(CustomPathParamMatcher),
-                Pattern = JsonConvert.SerializeObject(patternModel)
-            };
+            Name = "SimMetricsMatcher.BlockDistance",
+            Pattern = "x"
+        };
 
-            var settings = new WireMockServerSettings();
-            settings.CustomMatcherMappings = settings.CustomMatcherMappings ?? new Dictionary<string, Func<MatcherModel, IMatcher>>();
-            settings.CustomMatcherMappings[nameof(CustomPathParamMatcher)] = matcherModel =>
-            {
-                var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)matcherModel.Pattern);
-                return new CustomPathParamMatcher(
-                    matcherModel.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch,
-                    matcherParams.Path, matcherParams.PathParams,
-                    settings.ThrowExceptionWhenMatcherFails == true
-                );
-            };
-            var sut = new MatcherMapper(settings);
+        // Act
+        var matcher = (SimMetricsMatcher)_sut.Map(model)!;
 
-            // Act
-            var matcher = sut.Map(model) as CustomPathParamMatcher;
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x");
+    }
 
-            // Assert
-            matcher.Should().NotBeNull();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_CustomMatcherToMatcherModel()
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var matcher = new CustomPathParamMatcher("/customer/{customerId}/document/{documentId}",
-                new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
+            Name = "error",
+            Pattern = "x"
+        };
 
-            // Act
-            var model = _sut.Map(matcher);
+        // Act
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
 
-            // Assert
-            using (new AssertionScope())
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "SimMetricsMatcher.error",
+            Pattern = "x"
+        };
+
+        // Act
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_MatcherModelToCustomMatcher()
+    {
+        // Arrange
+        var patternModel = new CustomPathParamMatcherModel("/customer/{customerId}/document/{documentId}",
+            new Dictionary<string, string>(2)
             {
-                model.Should().NotBeNull();
-                model.Name.Should().Be(nameof(CustomPathParamMatcher));
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
+        var model = new MatcherModel
+        {
+            Name = nameof(CustomPathParamMatcher),
+            Pattern = JsonConvert.SerializeObject(patternModel)
+        };
 
-                var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)model.Pattern);
-                matcherParams.Path.Should().Be("/customer/{customerId}/document/{documentId}");
-                matcherParams.PathParams.Should().BeEquivalentTo(new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
-            }
+        var settings = new WireMockServerSettings();
+        settings.CustomMatcherMappings = settings.CustomMatcherMappings ?? new Dictionary<string, Func<MatcherModel, IMatcher>>();
+        settings.CustomMatcherMappings[nameof(CustomPathParamMatcher)] = matcherModel =>
+        {
+            var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)matcherModel.Pattern!)!;
+            return new CustomPathParamMatcher(
+                matcherModel.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch,
+                matcherParams.Path,
+                matcherParams.PathParams,
+                settings.ThrowExceptionWhenMatcherFails == true
+            );
+        };
+        var sut = new MatcherMapper(settings);
+
+        // Act
+        var matcher = sut.Map(model) as CustomPathParamMatcher;
+
+        // Assert
+        matcher.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_CustomMatcherToMatcherModel()
+    {
+        // Arrange
+        var matcher = new CustomPathParamMatcher("/customer/{customerId}/document/{documentId}",
+            new Dictionary<string, string>(2)
+            {
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
+
+        // Act
+        var model = _sut.Map(matcher)!;
+
+        // Assert
+        using (new AssertionScope())
+        {
+            model.Should().NotBeNull();
+            model.Name.Should().Be(nameof(CustomPathParamMatcher));
+
+            var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)model.Pattern!)!;
+            matcherParams.Path.Should().Be("/customer/{customerId}/document/{documentId}");
+            matcherParams.PathParams.Should().BeEquivalentTo(new Dictionary<string, string>(2)
+            {
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
         }
     }
 }