Changelog for 1.0.3.17

Merge pull request #138 from WireMock-Net/stef_negate_matcher
Added Negate matcher logic
2026-01-14 06:13:35 +01:00 · 2018-05-16 22:30:25 +02:00 · 2018-05-16 20:19:48 +01:00 · 2018-05-15 12:41:07 +02:00 · 2018-05-12 12:51:56 +02:00 · 2018-05-12 12:45:58 +02:00
79 changed files with 1846 additions and 629 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,41 @@
+# 1.0.3.17 (16 May 2018)
+
+ - [#138](https://github.com/WireMock-Net/WireMock.Net/pull/138) - Added Negate matcher logic contributed by Stef Heyenrath ([StefH](https://github.com/StefH))
+ - [#135](https://github.com/WireMock-Net/WireMock.Net/pull/135) - Merge into the stef_negate_matcher branch (solves issue #133) contributed by Stef Heyenrath ([StefH](https://github.com/StefH))
+ - [#134](https://github.com/WireMock-Net/WireMock.Net/pull/134) - Stef negate matcher contributed by Alastair Crabtree ([alastairtree](https://github.com/alastairtree))
+ - [#133](https://github.com/WireMock-Net/WireMock.Net/issues/133) - Issue: Wildcard matching a json body does not work? +fix
+ - [#128](https://github.com/WireMock-Net/WireMock.Net/issues/128) - Feature: Negate a matcher +feature
+ - [#126](https://github.com/WireMock-Net/WireMock.Net/issues/126) - Question: UsingHead always returns 0 for Content-Length header even when explicitly specified
+ - [#103](https://github.com/WireMock-Net/WireMock.Net/issues/103) - Support for Faults
+
+Commits: 0fb4b62b50...c575ca8296
+
+
+# 1.0.3.16 (15 April 2018)
+
+ - [#125](https://github.com/WireMock-Net/WireMock.Net/pull/125) - Change listen from loopback to any ip address for dotnetcore2.0 apps contributed by ([SubjectiveReality](https://github.com/SubjectiveReality))
+ - [#124](https://github.com/WireMock-Net/WireMock.Net/issues/124) - Issue: Unable to get host to listen on ips other than 127.0.0.1 using StandAloneApp
+ - [#121](https://github.com/WireMock-Net/WireMock.Net/pull/121) - Fix for issue #118 contributed by ([raghavendrabankapur](https://github.com/raghavendrabankapur)) +fix
+ - [#118](https://github.com/WireMock-Net/WireMock.Net/issues/118) - Not reading the response from a file when mappings are placed in json file
+
+Commits: 7bd63a0baf...1bcdfe31ab
+
+
+# 1.0.3.15 (05 April 2018)
+
+ - [#117](https://github.com/WireMock-Net/WireMock.Net/pull/117) - Respect start timeout setting and expose exception from server startup contributed by Evan Liang ([evanlwj](https://github.com/evanlwj))
+
+Commits: 2d2a2dd6fc...4f294baff2
+
+
+# 1.0.3.14 (01 April 2018)
+
+ - [#114](https://github.com/WireMock-Net/WireMock.Net/issues/114) - Feature: Add PathSegments in Transform +feature
+ - [#113](https://github.com/WireMock-Net/WireMock.Net/issues/113) - Feature: Add BodyAsJsonIndented for response message +feature
+
+Commits: bdb79aec95...e87f970057
+
+
 # 1.0.3.12 (24 March 2018)

 - [#100](https://github.com/WireMock-Net/WireMock.Net/issues/100) - Issue: JsonPathMatcher - not working for rootless jsons?
--- a/GitReleaseNotes.txt
+++ b/GitReleaseNotes.txt
@@ -1,5 +1,5 @@
 https://github.com/GitTools/GitReleaseNotes

-GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.3.11
+GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.3.17

 GitReleaseNotes.exe . /OutputFile CHANGELOG.md /allTags
--- a/Solution.sln
+++ b/Solution.sln
@@ -14,6 +14,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		GitReleaseNotes.txt = GitReleaseNotes.txt
 		README.md = README.md
 		ReSharper_WireMock.DotSettings = ReSharper_WireMock.DotSettings
+		WireMock.Net Solution.sln.DotSettings = WireMock.Net Solution.sln.DotSettings
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{F0C22C47-DF71-463C-9B04-B4E0F3B8708A}"
--- a/Solution.sln.DotSettings
+++ b/Solution.sln.DotSettings
@@ -1,3 +1,11 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=ID/@EntryIndexedValue">ID</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SSL/@EntryIndexedValue">SSL</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MD/@EntryIndexedValue">MD5</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SSL/@EntryIndexedValue">SSL</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TE/@EntryIndexedValue">TE</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TSV/@EntryIndexedValue">TSV</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=WWW/@EntryIndexedValue">WWW</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XMS/@EntryIndexedValue">XMS</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XUA/@EntryIndexedValue">XUA</s:String>
+</wpf:ResourceDictionary>
--- a/examples/WireMock.Net.ConsoleApplication/MainApp.cs
+++ b/examples/WireMock.Net.ConsoleApplication/MainApp.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net;
 using Newtonsoft.Json;
 using WireMock.Matchers;
 using WireMock.RequestBuilders;
@@ -150,6 +151,28 @@ namespace WireMock.Net.ConsoleApplication
                    .WithHeader("Content-Type", "application/json")
                    .WithBody(@"{ ""result"": ""data deleted with 200""}"));

+            server
+                .Given(Request.Create()
+                    .WithPath("/needs-a-key")
+                    .UsingGet()
+                    .WithHeader("api-key", "*", MatchBehaviour.AcceptOnMatch)
+                    .UsingAnyMethod())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(HttpStatusCode.OK)
+                    .WithBody(@"{ ""result"": ""api-key found""}"));
+
+            server
+                .Given(Request.Create()
+                    .WithPath("/needs-a-key")
+                    .UsingGet()
+                    .WithHeader("api-key", "*", MatchBehaviour.RejectOnMatch)
+                    .UsingAnyMethod())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(HttpStatusCode.Unauthorized)
+                    .WithBody(@"{ ""result"": ""api-key missing""}"));
+
+
+
            server
                .Given(Request.Create().WithPath("/nobody").UsingGet())
                .RespondWith(Response.Create().WithDelay(TimeSpan.FromSeconds(1))
@@ -160,18 +183,17 @@ namespace WireMock.Net.ConsoleApplication
                .RespondWith(Response.Create().WithStatusCode(200).WithBody("partial = 200"));

            // http://localhost:8080/any/any?start=1000&stop=1&stop=2
-            //server
-            //    .Given(Request.Create().WithPath("/*").UsingGet())
-            //    .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
-            //    .AtPriority(server.Mappings.Count() + 1)
-            //    .RespondWith(Response.Create()
-            //        .WithStatusCode(200)
-            //        .WithHeader("Content-Type", "application/json")
-            //        .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
-            //        .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
-            //        .WithTransformer()
-            //        .WithDelay(TimeSpan.FromMilliseconds(100))
-            //    );
+            server
+                .Given(Request.Create().WithPath("/trans").UsingGet())
+                .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
+                .RespondWith(Response.Create()
+                    .WithStatusCode(200)
+                    .WithHeader("Content-Type", "application/json")
+                    .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
+                    .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
+                    .WithTransformer()
+                    .WithDelay(TimeSpan.FromMilliseconds(100))
+                );

            server
                .Given(Request.Create()
--- a/src/WireMock.Net.StandAlone/WireMock.Net.StandAlone.csproj
+++ b/src/WireMock.Net.StandAlone/WireMock.Net.StandAlone.csproj
@@ -3,7 +3,7 @@
  <PropertyGroup>
    <Description>Lightweight StandAlone Http Mocking Server for .Net.</Description>
    <AssemblyTitle>WireMock.Net.StandAlone</AssemblyTitle>
-    <Version>1.0.3.13</Version>
+    <Version>1.0.3.17</Version>
    <Authors>Stef Heyenrath</Authors>
    <TargetFrameworks>net452;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
--- a/src/WireMock.Net/Admin/Mappings/MatcherModel.cs
+++ b/src/WireMock.Net/Admin/Mappings/MatcherModel.cs
@@ -24,5 +24,10 @@
        /// Gets or sets the ignore case.
        /// </summary>
        public bool? IgnoreCase { get; set; }
+
+        /// <summary>
+        /// Reject on match.
+        /// </summary>
+        public bool? RejectOnMatch { get; set; }
    }
 }
--- a/src/WireMock.Net/Admin/Mappings/ResponseModel.cs
+++ b/src/WireMock.Net/Admin/Mappings/ResponseModel.cs
@@ -32,6 +32,11 @@ namespace WireMock.Admin.Mappings
        /// </summary>
        public object BodyAsJson { get; set; }

+        /// <summary>
+        /// Gets or sets a value indicating whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.
+        /// </summary>
+        public bool? BodyAsJsonIndented { get; set; }
+
        /// <summary>
        /// Gets or sets the body (as bytearray).
        /// </summary>
--- a/src/WireMock.Net/Matchers/ExactMatcher.cs
+++ b/src/WireMock.Net/Matchers/ExactMatcher.cs
@@ -12,21 +12,34 @@ namespace WireMock.Matchers
    {
        private readonly string[] _values;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
        /// </summary>
        /// <param name="values">The values.</param>
-        public ExactMatcher([NotNull] params string[] values)
+        public ExactMatcher([NotNull] params string[] values) : this(MatchBehaviour.AcceptOnMatch, values)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="values">The values.</param>
+        public ExactMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] values)
        {
            Check.HasNoNulls(values, nameof(values));

            _values = values;
+            MatchBehaviour = matchBehaviour;
        }

        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
        public double IsMatch(string input)
        {
-            return MatchScores.ToScore(_values.Select(value => value.Equals(input)));
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values.Select(value => value.Equals(input))));
        }

        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -35,10 +48,7 @@ namespace WireMock.Matchers
            return _values;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "ExactMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactMatcher";
    }
 }
--- a/src/WireMock.Net/Matchers/ExactObjectMatcher.cs
+++ b/src/WireMock.Net/Matchers/ExactObjectMatcher.cs
@@ -1,5 +1,6 @@
 using System.Linq;
 using JetBrains.Annotations;
+using WireMock.Validation;

 namespace WireMock.Matchers
 {
@@ -12,35 +13,59 @@ namespace WireMock.Matchers
        private readonly object _object;
        private readonly byte[] _bytes;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
        /// </summary>
        /// <param name="value">The value.</param>
-        public ExactObjectMatcher([NotNull] object value)
+        public ExactObjectMatcher([NotNull] object value) : this(MatchBehaviour.AcceptOnMatch, value)
        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="value">The value.</param>
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] object value)
+        {
+            Check.NotNull(value, nameof(value));
+
            _object = value;
+            MatchBehaviour = matchBehaviour;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
        /// </summary>
        /// <param name="value">The value.</param>
-        public ExactObjectMatcher([NotNull] byte[] value)
+        public ExactObjectMatcher([NotNull] byte[] value) : this(MatchBehaviour.AcceptOnMatch, value)
        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="value">The value.</param>
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] byte[] value)
+        {
+            Check.NotNull(value, nameof(value));
+
            _bytes = value;
+            MatchBehaviour = matchBehaviour;
        }

        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
        public double IsMatch(object input)
        {
            bool equals = _object != null ? Equals(_object, input) : _bytes.SequenceEqual((byte[])input);
-            return MatchScores.ToScore(equals);
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(equals));
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "ExactObjectMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactObjectMatcher";
    }
 }
--- a/src/WireMock.Net/Matchers/IIgnoreCaseMatcher.cs
+++ b/src/WireMock.Net/Matchers/IIgnoreCaseMatcher.cs
@@ -3,10 +3,11 @@
    /// <summary>
    /// IIgnoreCaseMatcher
    /// </summary>
+    /// <inheritdoc cref="IMatcher"/>
    public interface IIgnoreCaseMatcher : IMatcher
    {
        /// <summary>
-        /// Ignore the case.
+        /// Ignore the case from the pattern.
        /// </summary>
        bool IgnoreCase { get; }
    }
--- a/src/WireMock.Net/Matchers/IMatcher.cs
+++ b/src/WireMock.Net/Matchers/IMatcher.cs
@@ -8,7 +8,12 @@
        /// <summary>
        /// Gets the name.
        /// </summary>
-        /// <returns>Name</returns>
-        string GetName();
+        string Name { get; }
+
+
+        /// <summary>
+        /// Gets the match behaviour.
+        /// </summary>
+        MatchBehaviour MatchBehaviour { get; }
    }
 }
--- a/src/WireMock.Net/Matchers/IStringMatcher.cs
+++ b/src/WireMock.Net/Matchers/IStringMatcher.cs
@@ -3,6 +3,7 @@
    /// <summary>
    /// IStringMatcher
    /// </summary>
+    /// <inheritdoc cref="IMatcher"/>
    public interface IStringMatcher : IMatcher
    {
        /// <summary>
--- a/src/WireMock.Net/Matchers/JSONPathMatcher.cs
+++ b/src/WireMock.Net/Matchers/JSONPathMatcher.cs
@@ -1,6 +1,6 @@
-using System;
-using System.Linq;
+using System.Linq;
 using JetBrains.Annotations;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using WireMock.Validation;

@@ -14,54 +14,69 @@ namespace WireMock.Matchers
    {
        private readonly string[] _patterns;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
        /// </summary>
        /// <param name="patterns">The patterns.</param>
-        public JsonPathMatcher([NotNull] params string[] patterns)
+        public JsonPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        public JsonPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
        {
            Check.NotNull(patterns, nameof(patterns));

+            MatchBehaviour = matchBehaviour;
            _patterns = patterns;
        }

        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
        public double IsMatch(string input)
        {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
            {
-                return MatchScores.Mismatch;
+                try
+                {
+                    var jtoken = JToken.Parse(input);
+                    match = IsMatch(jtoken);
+                }
+                catch (JsonException)
+                {
+                    // just ignore JsonException
+                }
            }

-            try
-            {
-                var jtoken = JToken.Parse(input);
-                return IsMatch(jtoken);
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
-            }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
        }

        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
        public double IsMatch(object input)
        {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
            {
-                return MatchScores.Mismatch;
+                try
+                {
+                    // Check if JToken or object
+                    JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
+                    match = IsMatch(jtoken);
+                }
+                catch (JsonException)
+                {
+                    // just ignore JsonException
+                }
            }

-            try
-            {
-                // Check if JToken or object
-                JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
-                return IsMatch(jtoken);
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
-            }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
        }

        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -70,11 +85,8 @@ namespace WireMock.Matchers
            return _patterns;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "JsonPathMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "JsonPathMatcher";

        private double IsMatch(JToken jtoken)
        {
--- a/src/WireMock.Net/Matchers/MatchBehaviour.cs
+++ b/src/WireMock.Net/Matchers/MatchBehaviour.cs
@@ -0,0 +1,18 @@
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// MatchBehaviour
+    /// </summary>
+    public enum MatchBehaviour
+    {
+        /// <summary>
+        /// Accept on match (default)
+        /// </summary>
+        AcceptOnMatch,
+
+        /// <summary>
+        /// Reject on match
+        /// </summary>
+        RejectOnMatch
+    }
+}
--- a/src/WireMock.Net/Matchers/MatchBehaviourHelper.cs
+++ b/src/WireMock.Net/Matchers/MatchBehaviourHelper.cs
@@ -0,0 +1,28 @@
+
+namespace WireMock.Matchers
+{
+    internal static class MatchBehaviourHelper
+    {
+        /// <summary>
+        /// Converts the specified match behaviour and match value to a new match value.
+        /// 
+        /// if AcceptOnMatch --> return match (default)
+        /// if RejectOnMatch and match = 0.0 --> return 1.0
+        /// if RejectOnMatch and match = 0.? --> return 0.0
+        /// if RejectOnMatch and match = 1.0 --> return 0.0
+        /// </summary>
+        /// 
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="match">The match.</param>
+        /// <returns>match value</returns>
+        internal static double Convert(MatchBehaviour matchBehaviour, double match)
+        {
+            if (matchBehaviour == MatchBehaviour.AcceptOnMatch)
+            {
+                return match;
+            }
+
+            return match <= MatchScores.Tolerance ? MatchScores.Perfect : MatchScores.Mismatch;
+        }
+    }
+}
--- a/src/WireMock.Net/Matchers/RegexMatcher.cs
+++ b/src/WireMock.Net/Matchers/RegexMatcher.cs
@@ -9,18 +9,32 @@ namespace WireMock.Matchers
    /// <summary>
    /// Regular Expression Matcher
    /// </summary>
-    /// <seealso cref="IStringMatcher" />
+    /// <inheritdoc cref="IStringMatcher"/>
+    /// <inheritdoc cref="IIgnoreCaseMatcher"/>
    public class RegexMatcher : IStringMatcher, IIgnoreCaseMatcher
    {
        private readonly string[] _patterns;
        private readonly Regex[] _expressions;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
        /// </summary>
        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
-        public RegexMatcher([NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(new [] { pattern }, ignoreCase )
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher([NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
        {
        }

@@ -28,13 +42,24 @@ namespace WireMock.Matchers
        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
        /// </summary>
        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
-        public RegexMatcher([NotNull, RegexPattern] string[] patterns, bool ignoreCase = false)
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher([NotNull, RegexPattern] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string[] patterns, bool ignoreCase = false)
        {
            Check.NotNull(patterns, nameof(patterns));

            _patterns = patterns;
            IgnoreCase = ignoreCase;
+            MatchBehaviour = matchBehaviour;

            RegexOptions options = RegexOptions.Compiled;
            if (ignoreCase)
@@ -48,19 +73,20 @@ namespace WireMock.Matchers
        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
        public double IsMatch(string input)
        {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
            {
-                return MatchScores.Mismatch;
-            }
-
-            try
-            {
-                return MatchScores.ToScore(_expressions.Select(e => e.IsMatch(input)));
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
+                try
+                {
+                    match = MatchScores.ToScore(_expressions.Select(e => e.IsMatch(input)));
+                }
+                catch (Exception)
+                {
+                    // just ignore exception
+                }
            }
+            
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
        }

        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -69,11 +95,8 @@ namespace WireMock.Matchers
            return _patterns;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public virtual string GetName()
-        {
-            return "RegexMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public virtual string Name => "RegexMatcher";

        /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
        public bool IgnoreCase { get; }
--- a/src/WireMock.Net/Matchers/Request/RequestMessageBodyMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageBodyMatcher.cs
@@ -32,24 +32,27 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="body">The body.</param>
-        public RequestMessageBodyMatcher([NotNull] string body) : this(new SimMetricsMatcher(body))
+        public RequestMessageBodyMatcher(MatchBehaviour matchBehaviour, [NotNull] string body) : this(new WildcardMatcher(matchBehaviour, body))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="body">The body.</param>
-        public RequestMessageBodyMatcher([NotNull] byte[] body) : this(new ExactObjectMatcher(body))
+        public RequestMessageBodyMatcher(MatchBehaviour matchBehaviour, [NotNull] byte[] body) : this(new ExactObjectMatcher(matchBehaviour, body))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="body">The body.</param>
-        public RequestMessageBodyMatcher([NotNull] object body) : this(new ExactObjectMatcher(body))
+        public RequestMessageBodyMatcher(MatchBehaviour matchBehaviour, [NotNull] object body) : this(new ExactObjectMatcher(matchBehaviour, body))
        {
        }

@@ -102,27 +105,38 @@ namespace WireMock.Matchers.Request

        private double IsMatch(RequestMessage requestMessage)
        {
-            if (requestMessage.Body != null)
-            {
-                if (Matcher is IStringMatcher stringMatcher)
-                {
-                    return stringMatcher.IsMatch(requestMessage.Body);
-                }
-            }
-
+            // Check if the matcher is a IObjectMatcher
            if (Matcher is IObjectMatcher objectMatcher)
            {
+                // If the body is a JSON object, try to match.
                if (requestMessage.BodyAsJson != null)
                {
                    return objectMatcher.IsMatch(requestMessage.BodyAsJson);
                }

+                // If the body is a byte array, try to match.
                if (requestMessage.BodyAsBytes != null)
                {
                    return objectMatcher.IsMatch(requestMessage.BodyAsBytes);
                }
            }

+            // Check if the matcher is a IStringMatcher
+            if (Matcher is IStringMatcher stringMatcher)
+            {
+                // If the  body is a JSON object, try to use Body (string) to match.
+                if (requestMessage.BodyAsJson != null && requestMessage.Body != null)
+                {
+                    return stringMatcher.IsMatch(requestMessage.Body);
+                }
+
+                // If the string body is defined, try to match.
+                if (requestMessage.Body != null)
+                {
+                    return stringMatcher.IsMatch(requestMessage.Body);
+                }
+            }
+
            if (Func != null)
            {
                return MatchScores.ToScore(requestMessage.Body != null && Func(requestMessage.Body));
--- a/src/WireMock.Net/Matchers/Request/RequestMessageClientIPMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageClientIPMatcher.cs
@@ -25,7 +25,8 @@ namespace WireMock.Matchers.Request
        /// Initializes a new instance of the <see cref="RequestMessageClientIPMatcher"/> class.
        /// </summary>
        /// <param name="clientIPs">The clientIPs.</param>
-        public RequestMessageClientIPMatcher([NotNull] params string[] clientIPs) : this(clientIPs.Select(ip => new WildcardMatcher(ip)).Cast<IStringMatcher>().ToArray())
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        public RequestMessageClientIPMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] clientIPs) : this(clientIPs.Select(ip => new WildcardMatcher(matchBehaviour, ip)).Cast<IStringMatcher>().ToArray())
        {
        }

--- a/src/WireMock.Net/Matchers/Request/RequestMessageCookieMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageCookieMatcher.cs
@@ -11,6 +11,8 @@ namespace WireMock.Matchers.Request
    /// </summary>
    public class RequestMessageCookieMatcher : IRequestMatcher
    {
+        private readonly MatchBehaviour _matchBehaviour;
+
        /// <value>
        /// The funcs.
        /// </value>
@@ -29,16 +31,18 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageCookieMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="name">The name.</param>
        /// <param name="pattern">The pattern.</param>
        /// <param name="ignoreCase">The ignoreCase.</param>
-        public RequestMessageCookieMatcher([NotNull] string name, [NotNull] string pattern, bool ignoreCase = true)
+        public RequestMessageCookieMatcher(MatchBehaviour matchBehaviour, [NotNull] string name, [NotNull] string pattern, bool ignoreCase = true)
        {
            Check.NotNull(name, nameof(name));
            Check.NotNull(pattern, nameof(pattern));

+            _matchBehaviour = matchBehaviour;
            Name = name;
-            Matchers = new IStringMatcher[] { new WildcardMatcher(pattern, ignoreCase) };
+            Matchers = new IStringMatcher[] { new WildcardMatcher(matchBehaviour, pattern, ignoreCase) };
        }

        /// <summary>
@@ -77,7 +81,7 @@ namespace WireMock.Matchers.Request
        {
            if (requestMessage.Cookies == null)
            {
-                return MatchScores.Mismatch;
+                return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
            }

            if (Funcs != null)
@@ -92,7 +96,7 @@ namespace WireMock.Matchers.Request

            if (!requestMessage.Cookies.ContainsKey(Name))
            {
-                return MatchScores.Mismatch;
+                return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
            }

            string value = requestMessage.Cookies[Name];
--- a/src/WireMock.Net/Matchers/Request/RequestMessageHeaderMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageHeaderMatcher.cs
@@ -13,6 +13,8 @@ namespace WireMock.Matchers.Request
    /// <inheritdoc cref="IRequestMatcher"/>
    public class RequestMessageHeaderMatcher : IRequestMatcher
    {
+        private readonly MatchBehaviour _matchBehaviour;
+
        /// <summary>
        /// The functions
        /// </summary>
@@ -33,14 +35,16 @@ namespace WireMock.Matchers.Request
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">if set to <c>true</c> [ignore case].</param>
-        public RequestMessageHeaderMatcher([NotNull] string name, [NotNull] string pattern, bool ignoreCase = true)
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        public RequestMessageHeaderMatcher(MatchBehaviour matchBehaviour, [NotNull] string name, [NotNull] string pattern, bool ignoreCase)
        {
            Check.NotNull(name, nameof(name));
            Check.NotNull(pattern, nameof(pattern));

+            _matchBehaviour = matchBehaviour;
            Name = name;
-            Matchers = new IStringMatcher[] { new WildcardMatcher(pattern, ignoreCase) };
+            Matchers = new IStringMatcher[] { new WildcardMatcher(matchBehaviour, pattern, ignoreCase) };
        }

        /// <summary>
@@ -48,14 +52,16 @@ namespace WireMock.Matchers.Request
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">if set to <c>true</c> [ignore case].</param>
-        public RequestMessageHeaderMatcher([NotNull] string name, [NotNull] string[] patterns, bool ignoreCase = true)
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        public RequestMessageHeaderMatcher(MatchBehaviour matchBehaviour, [NotNull] string name, [NotNull] string[] patterns, bool ignoreCase)
        {
            Check.NotNull(name, nameof(name));
            Check.NotNull(patterns, nameof(patterns));

+            _matchBehaviour = matchBehaviour;
            Name = name;
-            Matchers = patterns.Select(pattern => new WildcardMatcher(pattern, ignoreCase)).Cast<IStringMatcher>().ToArray();
+            Matchers = patterns.Select(pattern => new WildcardMatcher(matchBehaviour, pattern, ignoreCase)).Cast<IStringMatcher>().ToArray();
        }

        /// <summary>
@@ -94,7 +100,7 @@ namespace WireMock.Matchers.Request
        {
            if (requestMessage.Headers == null)
            {
-                return MatchScores.Mismatch;
+                return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
            }

            if (Funcs != null)
@@ -109,7 +115,7 @@ namespace WireMock.Matchers.Request

            if (!requestMessage.Headers.ContainsKey(Name))
            {
-                return MatchScores.Mismatch;
+                return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
            }

            WireMockList<string> list = requestMessage.Headers[Name];
--- a/src/WireMock.Net/Matchers/Request/RequestMessageMethodMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageMethodMatcher.cs
@@ -9,6 +9,8 @@ namespace WireMock.Matchers.Request
    /// </summary>
    internal class RequestMessageMethodMatcher : IRequestMatcher
    {
+        private readonly MatchBehaviour _matchBehaviour;
+
        /// <summary>
        /// The methods
        /// </summary>
@@ -17,26 +19,20 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageMethodMatcher"/> class.
        /// </summary>
-        /// <param name="methods">
-        /// The verb.
-        /// </param>
-        public RequestMessageMethodMatcher([NotNull] params string[] methods)
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="methods">The methods.</param>
+        public RequestMessageMethodMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] methods)
        {
            Check.NotNull(methods, nameof(methods));
+            _matchBehaviour = matchBehaviour;
+
            Methods = methods.Select(v => v.ToLower()).ToArray();
        }

-        /// <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>
+        /// <inheritdoc cref="IRequestMatcher.GetMatchingScore"/>
        public double GetMatchingScore(RequestMessage requestMessage, RequestMatchResult requestMatchResult)
        {
-            double score = IsMatch(requestMessage);
+            double score = MatchBehaviourHelper.Convert(_matchBehaviour, IsMatch(requestMessage));
            return requestMatchResult.AddScore(GetType(), score);
        }

--- a/src/WireMock.Net/Matchers/Request/RequestMessageParamMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageParamMatcher.cs
@@ -12,6 +12,8 @@ namespace WireMock.Matchers.Request
    /// </summary>
    public class RequestMessageParamMatcher : IRequestMatcher
    {
+        private readonly MatchBehaviour _matchBehaviour;
+
        /// <summary>
        /// The funcs
        /// </summary>
@@ -30,20 +32,23 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageParamMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="key">The key.</param>
-        public RequestMessageParamMatcher([NotNull] string key) : this(key, null)
+        public RequestMessageParamMatcher(MatchBehaviour matchBehaviour, [NotNull] string key) : this(matchBehaviour, key, null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageParamMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="key">The key.</param>
        /// <param name="values">The values.</param>
-        public RequestMessageParamMatcher([NotNull] string key, [CanBeNull] IEnumerable<string> values)
+        public RequestMessageParamMatcher(MatchBehaviour matchBehaviour, [NotNull] string key, [CanBeNull] IEnumerable<string> values)
        {
            Check.NotNull(key, nameof(key));

+            _matchBehaviour = matchBehaviour;
            Key = key;
            Values = values;
        }
@@ -62,7 +67,7 @@ namespace WireMock.Matchers.Request
        /// <inheritdoc cref="IRequestMatcher.GetMatchingScore"/>
        public double GetMatchingScore(RequestMessage requestMessage, RequestMatchResult requestMatchResult)
        {
-            double score = IsMatch(requestMessage);
+            double score = MatchBehaviourHelper.Convert(_matchBehaviour, IsMatch(requestMessage));
            return requestMatchResult.AddScore(GetType(), score);
        }

--- a/src/WireMock.Net/Matchers/Request/RequestMessagePathMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessagePathMatcher.cs
@@ -12,7 +12,7 @@ namespace WireMock.Matchers.Request
    public class RequestMessagePathMatcher : IRequestMatcher
    {
        /// <summary>
-        /// The matcher.
+        /// The matchers
        /// </summary>
        public IReadOnlyList<IStringMatcher> Matchers { get; }

@@ -24,8 +24,9 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessagePathMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="paths">The paths.</param>
-        public RequestMessagePathMatcher([NotNull] params string[] paths) : this(paths.Select(path => new WildcardMatcher(path)).Cast<IStringMatcher>().ToArray())
+        public RequestMessagePathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] paths) : this(paths.Select(path => new WildcardMatcher(matchBehaviour, path)).Cast<IStringMatcher>().ToArray())
        {
        }

@@ -36,6 +37,7 @@ namespace WireMock.Matchers.Request
        public RequestMessagePathMatcher([NotNull] params IStringMatcher[] matchers)
        {
            Check.NotNull(matchers, nameof(matchers));
+
            Matchers = matchers;
        }

@@ -46,6 +48,7 @@ namespace WireMock.Matchers.Request
        public RequestMessagePathMatcher([NotNull] params Func<string, bool>[] funcs)
        {
            Check.NotNull(funcs, nameof(funcs));
+
            Funcs = funcs;
        }

--- a/src/WireMock.Net/Matchers/Request/RequestMessageUrlMatcher.cs
+++ b/src/WireMock.Net/Matchers/Request/RequestMessageUrlMatcher.cs
@@ -24,8 +24,9 @@ namespace WireMock.Matchers.Request
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestMessageUrlMatcher"/> class.
        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <param name="urls">The urls.</param>
-        public RequestMessageUrlMatcher([NotNull] params string[] urls) : this(urls.Select(url => new WildcardMatcher(url)).Cast<IStringMatcher>().ToArray())
+        public RequestMessageUrlMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] urls) : this(urls.Select(url => new WildcardMatcher(matchBehaviour, url)).Cast<IStringMatcher>().ToArray())
        {
        }

--- a/src/WireMock.Net/Matchers/SimMetricsMatcher.cs
+++ b/src/WireMock.Net/Matchers/SimMetricsMatcher.cs
@@ -16,12 +16,25 @@ namespace WireMock.Matchers
        private readonly string[] _patterns;
        private readonly SimMetricType _simMetricType;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
        /// </summary>
        /// <param name="pattern">The pattern.</param>
        /// <param name="simMetricType">The SimMetric Type</param>
-        public SimMetricsMatcher([NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(new [] { pattern }, simMetricType)
+        public SimMetricsMatcher([NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(new[] { pattern }, simMetricType)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="simMetricType">The SimMetric Type</param>
+        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(matchBehaviour, new[] { pattern }, simMetricType)
        {
        }

@@ -30,10 +43,21 @@ namespace WireMock.Matchers
        /// </summary>
        /// <param name="patterns">The patterns.</param>
        /// <param name="simMetricType">The SimMetric Type</param>
-        public SimMetricsMatcher([NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein)
+        public SimMetricsMatcher([NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein) : this(MatchBehaviour.AcceptOnMatch, patterns, simMetricType)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="simMetricType">The SimMetric Type</param>
+        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein)
        {
            Check.NotNullOrEmpty(patterns, nameof(patterns));

+            MatchBehaviour = matchBehaviour;
            _patterns = patterns;
            _simMetricType = simMetricType;
        }
@@ -43,7 +67,7 @@ namespace WireMock.Matchers
        {
            IStringMetric m = GetStringMetricType();

-            return MatchScores.ToScore(_patterns.Select(p => m.GetSimilarity(p, input)));
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_patterns.Select(p => m.GetSimilarity(p, input))));
        }

        private IStringMetric GetStringMetricType()
@@ -95,10 +119,7 @@ namespace WireMock.Matchers
            return _patterns;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return $"SimMetricsMatcher.{_simMetricType}";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => $"SimMetricsMatcher.{_simMetricType}";
    }
 }
--- a/src/WireMock.Net/Matchers/WildcardMatcher.cs
+++ b/src/WireMock.Net/Matchers/WildcardMatcher.cs
@@ -17,7 +17,17 @@ namespace WireMock.Matchers
        /// </summary>
        /// <param name="pattern">The pattern.</param>
        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new [] { pattern }, ignoreCase)
+        public WildcardMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
+        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
        {
        }

@@ -26,7 +36,17 @@ namespace WireMock.Matchers
        /// </summary>
        /// <param name="patterns">The patterns.</param>
        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher([NotNull] string[] patterns, bool ignoreCase = false) : base(patterns.Select(pattern => "^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$").ToArray(), ignoreCase)
+        public WildcardMatcher([NotNull] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
+        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, bool ignoreCase = false) : base(matchBehaviour, patterns.Select(pattern => "^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$").ToArray(), ignoreCase)
        {
            _patterns = patterns;
        }
@@ -37,10 +57,7 @@ namespace WireMock.Matchers
            return _patterns;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public override string GetName()
-        {
-            return "WildcardMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public override string Name => "WildcardMatcher";
    }
 }
--- a/src/WireMock.Net/Matchers/XPathMatcher.cs
+++ b/src/WireMock.Net/Matchers/XPathMatcher.cs
@@ -17,38 +17,52 @@ namespace WireMock.Matchers
    {
        private readonly string[] _patterns;

+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
        /// <summary>
        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
        /// </summary>
        /// <param name="patterns">The patterns.</param>
-        public XPathMatcher([NotNull] params string[] patterns)
+        public XPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        public XPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
        {
            Check.NotNull(patterns, nameof(patterns));

+            MatchBehaviour = matchBehaviour;
            _patterns = patterns;
        }

        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
        public double IsMatch(string input)
        {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
            {
-                return MatchScores.Mismatch;
+                try
+                {
+                    var nav = new XmlDocument { InnerXml = input }.CreateNavigator();
+#if NETSTANDARD1_3
+                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.Evaluate($"boolean({p})"))));
+#else
+                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.XPath2Evaluate($"boolean({p})"))));
+#endif
+                }
+                catch (Exception)
+                {
+                    // just ignore exception
+                }
            }

-            try
-            {
-                var nav = new XmlDocument { InnerXml = input }.CreateNavigator();
-#if NETSTANDARD1_3
-                return MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.Evaluate($"boolean({p})"))));
-#else
-                return MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.XPath2Evaluate($"boolean({p})"))));
-#endif
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
-            }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
        }

        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -57,10 +71,7 @@ namespace WireMock.Matchers
            return _patterns;
        }

-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "XPathMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "XPathMatcher";
    }
 }
--- a/src/WireMock.Net/Owin/AspNetCoreSelfHost.cs
+++ b/src/WireMock.Net/Owin/AspNetCoreSelfHost.cs
@@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using WireMock.Http;
 using WireMock.HttpsCertificate;
+using WireMock.Logging;
 using WireMock.Validation;

 namespace WireMock.Owin
@@ -18,6 +19,8 @@ namespace WireMock.Owin
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
        private readonly WireMockMiddlewareOptions _options;
        private readonly string[] _urls;
+        private readonly IWireMockLogger _logger;
+        private Exception _runningException;

        private IWebHost _host;

@@ -27,11 +30,15 @@ namespace WireMock.Owin

        public List<int> Ports { get; } = new List<int>();

+        public Exception RunningException => _runningException;
+
        public AspNetCoreSelfHost([NotNull] WireMockMiddlewareOptions options, [NotNull] params string[] uriPrefixes)
        {
            Check.NotNull(options, nameof(options));
            Check.NotNullOrEmpty(uriPrefixes, nameof(uriPrefixes));

+            _logger = options.Logger ?? new WireMockConsoleLogger();
+
            foreach (string uriPrefix in uriPrefixes)
            {
                Urls.Add(uriPrefix);
@@ -69,13 +76,13 @@ namespace WireMock.Owin
                    foreach (string url in _urls.Where(u => u.StartsWith("http://", StringComparison.OrdinalIgnoreCase)))
                    {
                        PortUtil.TryExtractProtocolAndPort(url, out string host, out int port);
-                        options.Listen(System.Net.IPAddress.Loopback, port);
+                        options.Listen(System.Net.IPAddress.Any, port);
                    }

                    foreach (string url in _urls.Where(u => u.StartsWith("https://", StringComparison.OrdinalIgnoreCase)))
                    {
                        PortUtil.TryExtractProtocolAndPort(url, out string host, out int port);
-                        options.Listen(System.Net.IPAddress.Loopback, port, listenOptions =>
+                        options.Listen(System.Net.IPAddress.Any, port, listenOptions =>
                        {
                            listenOptions.UseHttps(PublicCertificateHelper.GetX509Certificate2());
                        });
@@ -89,20 +96,34 @@ namespace WireMock.Owin

            IsStarted = true;

-#if NETSTANDARD1_3
-            Console.WriteLine("WireMock.Net server using netstandard1.3");
            return Task.Run(() =>
            {
-                _host.Run(_cts.Token);
+                StartServers();
            }, _cts.Token);
-#else
-            System.Console.WriteLine("WireMock.Net server using netstandard2.0");
+        }

-            return Task.Run(() =>
+        private void StartServers()
+        {
+            try
            {
+                IsStarted = true;
+#if NETSTANDARD1_3
+                _logger.Info("WireMock.Net server using netstandard1.3");
+                _host.Run(_cts.Token);
+#else
+                _logger.Info("WireMock.Net server using netstandard2.0");
                _host.Run();
-            }, _cts.Token);
 #endif
+            }
+            catch (Exception e)
+            {
+                _runningException = e;
+                _logger.Error(e.ToString());
+            }
+            finally
+            {
+                IsStarted = false;
+            }
        }

        public Task StopAsync()
--- a/src/WireMock.Net/Owin/IOwinSelfHost.cs
+++ b/src/WireMock.Net/Owin/IOwinSelfHost.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using System;

 namespace WireMock.Owin
 {
@@ -16,19 +17,18 @@ namespace WireMock.Owin
        /// <summary>
        /// Gets the urls.
        /// </summary>
-        /// <value>
-        /// The urls.
-        /// </value>
        List<string> Urls { get; }

        /// <summary>
        /// Gets the ports.
        /// </summary>
-        /// <value>
-        /// The ports.
-        /// </value>
        List<int> Ports { get; }

+        /// <summary>
+        /// The exception occurred when the host is running
+        /// </summary>
+        Exception RunningException { get; }
+
        Task StartAsync();

        Task StopAsync();
--- a/src/WireMock.Net/Owin/OwinRequestMapper.cs
+++ b/src/WireMock.Net/Owin/OwinRequestMapper.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-// using System.IO;
 using System.Linq;
-// using System.Text;
 using System.Threading.Tasks;
 using WireMock.Util;
 #if !NETSTANDARD
--- a/src/WireMock.Net/Owin/OwinResponseMapper.cs
+++ b/src/WireMock.Net/Owin/OwinResponseMapper.cs
@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
+using WireMock.Http;
 using WireMock.Util;
 #if !NETSTANDARD
 using Microsoft.Owin;
@@ -21,17 +22,27 @@ namespace WireMock.Owin
    {
        private readonly Encoding _utf8NoBom = new UTF8Encoding(false);

-        // https://stackoverflow.com/questions/239725/cannot-set-some-http-headers-when-using-system-net-webrequest
+        // https://msdn.microsoft.com/en-us/library/78h415ay(v=vs.110).aspx
 #if !NETSTANDARD
        private static readonly IDictionary<string, Action<IOwinResponse, WireMockList<string>>> RestrictedResponseHeaders = new Dictionary<string, Action<IOwinResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
 #else
        private static readonly IDictionary<string, Action<HttpResponse, WireMockList<string>>> RestrictedResponseHeaders = new Dictionary<string, Action<HttpResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
 #endif
-            { "Content-Length", null },
-            { "Content-Type", (r, v) => r.ContentType = v.FirstOrDefault() },
-            { "Keep-Alive", null },
-            { "Transfer-Encoding", null },
-            { "WWW-Authenticate", null }
+            { HttpKnownHeaderNames.Accept, null },
+            { HttpKnownHeaderNames.Connection, null },
+            { HttpKnownHeaderNames.ContentLength, null },
+            { HttpKnownHeaderNames.ContentType, (r, v) => r.ContentType = v.FirstOrDefault() },
+            { HttpKnownHeaderNames.Date, null },
+            { HttpKnownHeaderNames.Expect, null },
+            { HttpKnownHeaderNames.Host, null },
+            { HttpKnownHeaderNames.IfModifiedSince, null },
+            { HttpKnownHeaderNames.KeepAlive, null },
+            { HttpKnownHeaderNames.Range, null },
+            { HttpKnownHeaderNames.Referer, null },
+            { HttpKnownHeaderNames.TransferEncoding, null },
+            { HttpKnownHeaderNames.UserAgent, null },
+            { HttpKnownHeaderNames.ProxyConnection, null },
+            { HttpKnownHeaderNames.WWWAuthenticate, null }
        };

        /// <summary>
@@ -87,7 +98,8 @@ namespace WireMock.Owin

            if (responseMessage.BodyAsJson != null)
            {
-                string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyAsJson, new JsonSerializerSettings { Formatting = Formatting.None, NullValueHandling = NullValueHandling.Ignore });
+                Formatting formatting = responseMessage.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
+                string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyAsJson, new JsonSerializerSettings { Formatting = formatting, NullValueHandling = NullValueHandling.Ignore });
                using (var writer = new StreamWriter(response.Body, responseMessage.BodyEncoding ?? _utf8NoBom))
                {
                    await writer.WriteAsync(jsonBody);
--- a/src/WireMock.Net/Owin/OwinSelfHost.cs
+++ b/src/WireMock.Net/Owin/OwinSelfHost.cs
@@ -1,13 +1,14 @@
 #if !NETSTANDARD
+using JetBrains.Annotations;
+using Microsoft.Owin.Hosting;
+using Owin;
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
-using WireMock.Validation;
-using Owin;
-using Microsoft.Owin.Hosting;
 using WireMock.Http;
+using WireMock.Logging;
+using WireMock.Validation;

 namespace WireMock.Owin
 {
@@ -15,12 +16,16 @@ namespace WireMock.Owin
    {
        private readonly WireMockMiddlewareOptions _options;
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
+        private readonly IWireMockLogger _logger;
+        private Exception _runningException;

        public OwinSelfHost([NotNull] WireMockMiddlewareOptions options, [NotNull] params string[] uriPrefixes)
        {
            Check.NotNull(options, nameof(options));
            Check.NotNullOrEmpty(uriPrefixes, nameof(uriPrefixes));

+            _logger = options.Logger ?? new WireMockConsoleLogger();
+
            foreach (string uriPrefix in uriPrefixes)
            {
                Urls.Add(uriPrefix);
@@ -38,6 +43,8 @@ namespace WireMock.Owin

        public List<int> Ports { get; } = new List<int>();

+        public Exception RunningException => _runningException;
+
        [PublicAPI]
        public Task StartAsync()
        {
@@ -58,37 +65,46 @@ namespace WireMock.Owin
        private void StartServers()
        {
 #if NET46
-            Console.WriteLine("WireMock.Net server using .net 4.6.x or higher");
+            _logger.Info("WireMock.Net server using .net 4.6.x or higher");
 #else
-            Console.WriteLine("WireMock.Net server using .net 4.5.x or higher");
+            _logger.Info("WireMock.Net server using .net 4.5.x or higher");
 #endif
-
-            Action<IAppBuilder> startup = app =>
-            {
-                app.Use<GlobalExceptionMiddleware>(_options);
-                _options.PreWireMockMiddlewareInit?.Invoke(app);
-                app.Use<WireMockMiddleware>(_options);
-                _options.PostWireMockMiddlewareInit?.Invoke(app);
-            };
-
            var servers = new List<IDisposable>();
-            foreach (var url in Urls)
+
+            try
            {
-                servers.Add(WebApp.Start(url, startup));
+                Action<IAppBuilder> startup = app =>
+                {
+                    app.Use<GlobalExceptionMiddleware>(_options);
+                    _options.PreWireMockMiddlewareInit?.Invoke(app);
+                    app.Use<WireMockMiddleware>(_options);
+                    _options.PostWireMockMiddlewareInit?.Invoke(app);
+                };
+
+                foreach (var url in Urls)
+                {
+                    servers.Add(WebApp.Start(url, startup));
+                }
+
+                IsStarted = true;
+
+                // WaitHandle is signaled when the token is cancelled,
+                // which will be more efficent than Thread.Sleep in while loop
+                _cts.Token.WaitHandle.WaitOne();
            }
-
-            IsStarted = true;
-
-            while (!_cts.IsCancellationRequested)
+            catch (Exception e)
            {
-                Thread.Sleep(30000);
+                // Expose exception of starting host, otherwise it's hard to be troubleshooting if keeping quiet
+                // For example, WebApp.Start will fail with System.MissingMemberException if Microsoft.Owin.Host.HttpListener.dll is being located
+                // https://stackoverflow.com/questions/25090211/owin-httplistener-not-located/31369857
+                _runningException = e;
+                _logger.Error(e.ToString());
            }
-
-            IsStarted = false;
-
-            foreach (var server in servers)
+            finally
            {
-                server.Dispose();
+                IsStarted = false;
+                // Dispose all servers in finally block to make sure clean up allocated resource on error happening
+                servers.ForEach(s => s.Dispose());
            }
        }
    }
--- a/src/WireMock.Net/RequestBuilders/IBodyRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IBodyRequestBuilder.cs
@@ -20,39 +20,42 @@ namespace WireMock.RequestBuilders
        /// WithBody: Body as string
        /// </summary>
        /// <param name="body">The body.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithBody(string body);
+        IRequestBuilder WithBody(string body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
        /// WithBody: Body as byte[]
        /// </summary>
        /// <param name="body">The body.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithBody(byte[] body);
+        IRequestBuilder WithBody(byte[] body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
        /// WithBody: Body as object
        /// </summary>
        /// <param name="body">The body.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithBody(object body);
+        IRequestBuilder WithBody(object body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        ///WithBody: func (string)
+        /// WithBody: func (string)
        /// </summary>
        /// <param name="func">The function.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithBody([NotNull] Func<string, bool> func);

        /// <summary>
-        ///WithBody: func (byte[])
+        /// WithBody: func (byte[])
        /// </summary>
        /// <param name="func">The function.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithBody([NotNull] Func<byte[], bool> func);

        /// <summary>
-        ///WithBody: func (object)
+        /// WithBody: func (object)
        /// </summary>
        /// <param name="func">The function.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
--- a/src/WireMock.Net/RequestBuilders/IClientIPRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IClientIPRequestBuilder.cs
@@ -10,21 +10,29 @@ namespace WireMock.RequestBuilders
    public interface IClientIPRequestBuilder : IUrlAndPathRequestBuilder
    {
        /// <summary>
-        /// The with ClientIP.
+        /// WithClientIP: add matching on ClientIP matchers.
        /// </summary>
        /// <param name="matchers">The matchers.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithClientIP([NotNull] params IStringMatcher[] matchers);

        /// <summary>
-        /// The with ClientIP.
+        /// WithClientIP: add matching on clientIPs.
        /// </summary>
        /// <param name="clientIPs">The clientIPs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithClientIP([NotNull] params string[] clientIPs);

        /// <summary>
-        /// The with ClientIP.
+        /// WithClientIP: add matching on clientIPs and matchBehaviour.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="clientIPs">The clientIPs.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithClientIP(MatchBehaviour matchBehaviour, [NotNull] params string[] clientIPs);
+
+        /// <summary>
+        /// WithClientIP: add matching on ClientIP funcs.
        /// </summary>
        /// <param name="funcs">The path funcs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
--- a/src/WireMock.Net/RequestBuilders/IHeadersAndCookiesRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IHeadersAndCookiesRequestBuilder.cs
@@ -12,25 +12,45 @@ namespace WireMock.RequestBuilders
    public interface IHeadersAndCookiesRequestBuilder : IBodyRequestBuilder, IRequestMatcher, IParamsRequestBuilder
    {
        /// <summary>
-        /// Add Header matching based on name, pattern and ignoreCase.
+        /// WithHeader: matching based on name, pattern and matchBehaviour.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">ignore Case</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithHeader([NotNull] string name, string pattern, bool ignoreCase = true);
+        IRequestBuilder WithHeader([NotNull] string name, string pattern, MatchBehaviour matchBehaviour);

        /// <summary>
-        /// Add Header matching based on name, patterns and ignoreCase.
+        /// WithHeader: matching based on name, pattern, ignoreCase and matchBehaviour.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithHeader([NotNull] string name, string pattern, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
+
+        /// <summary>
+        /// WithHeader: matching based on name, patterns and matchBehaviour.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">ignore Case</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithHeader([NotNull] string name, string[] patterns, bool ignoreCase = true);
+        IRequestBuilder WithHeader([NotNull] string name, string[] patterns, MatchBehaviour matchBehaviour);

        /// <summary>
-        /// The with header.
+        /// WithHeader: matching based on name, patterns, ignoreCase and matchBehaviour.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithHeader([NotNull] string name, string[] patterns, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
+
+        /// <summary>
+        /// WithHeader: matching based on name and IStringMatcher[].
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="matchers">The matchers.</param>
@@ -38,23 +58,24 @@ namespace WireMock.RequestBuilders
        IRequestBuilder WithHeader([NotNull] string name, [NotNull] params IStringMatcher[] matchers);

        /// <summary>
-        /// The with header.
+        /// WithHeader: matching based on functions.
        /// </summary>
        /// <param name="funcs">The headers funcs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithHeader([NotNull] params Func<IDictionary<string, string[]>, bool>[] funcs);

        /// <summary>
-        /// The with cookie.
+        /// WithCookie: cookie matching based on name, pattern, ignoreCase and matchBehaviour.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">ignore Case</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithCookie([NotNull] string name, string pattern, bool ignoreCase = true);
+        IRequestBuilder WithCookie([NotNull] string name, string pattern, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The with cookie.
+        /// WithCookie: matching based on name and IStringMatcher[].
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="matchers">The matchers.</param>
@@ -62,7 +83,7 @@ namespace WireMock.RequestBuilders
        IRequestBuilder WithCookie([NotNull] string name, [NotNull] params IStringMatcher[] matchers);

        /// <summary>
-        /// The with cookie.
+        /// WithCookie: matching based on functions.
        /// </summary>
        /// <param name="cookieFuncs">The funcs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
--- a/src/WireMock.Net/RequestBuilders/IMethodRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IMethodRequestBuilder.cs
@@ -1,4 +1,6 @@
-using JetBrains.Annotations;
+using System;
+using JetBrains.Annotations;
+using WireMock.Matchers;

 namespace WireMock.RequestBuilders
 {
@@ -8,66 +10,81 @@ namespace WireMock.RequestBuilders
    public interface IMethodRequestBuilder : IHeadersAndCookiesRequestBuilder
    {
        /// <summary>
-        /// The using delete.
+        /// UsingDelete: add HTTP Method matching on `delete` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingDelete();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingDelete(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using get.
+        /// UsingGet: add HTTP Method matching on `get` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingGet();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingGet(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using head.
+        /// Add HTTP Method matching on `head` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingHead();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingHead(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using post.
+        /// UsingPost: add HTTP Method matching on `post` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingPost();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingPost(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using patch.
+        /// UsingPatch: add HTTP Method matching on `patch` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingPatch();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingPatch(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using put.
+        /// UsingPut: add HTTP Method matching on `put` and matchBehaviour (optional).
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
-        IRequestBuilder UsingPut();
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingPut(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// The using any verb.
+        /// UsingAnyMethod: add HTTP Method matching on any method.
        /// </summary>
-        /// <returns>
-        /// The <see cref="IRequestBuilder"/>.
-        /// </returns>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingAnyMethod();
+
+        /// <summary>
+        /// UsingAnyVerb: add HTTP Method matching on any method.
+        /// </summary>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        [Obsolete]
        IRequestBuilder UsingAnyVerb();

        /// <summary>
-        /// The using verb.
+        /// UsingMethod: add HTTP Method matching on any methods and matchBehaviour.
        /// </summary>
-        /// <param name="verbs">The verb.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="methods">The methods.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingMethod(MatchBehaviour matchBehaviour, [NotNull] params string[] methods);
+
+        /// <summary>
+        /// UsingMethod: add HTTP Method matching on any methods.
+        /// </summary>
+        /// <param name="methods">The methods.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder UsingMethod([NotNull] params string[] methods);
+
+        /// <summary>
+        /// UsingVerb: add HTTP Method matching on any methods.
+        /// </summary>
+        /// <param name="verbs">The methods.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        [Obsolete]
        IRequestBuilder UsingVerb([NotNull] params string[] verbs);
    }
 }
--- a/src/WireMock.Net/RequestBuilders/IParamsRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IParamsRequestBuilder.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
+using WireMock.Matchers;
 using WireMock.Util;

 namespace WireMock.RequestBuilders
@@ -11,14 +12,15 @@ namespace WireMock.RequestBuilders
    public interface IParamsRequestBuilder
    {
        /// <summary>
-        /// WithParam (key only)
+        /// WithParam: matching on key only.
        /// </summary>
        /// <param name="key">The key.</param>
+        /// <param name="matchBehaviour">The match behaviour (optional).</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        IRequestBuilder WithParam([NotNull] string key);
+        IRequestBuilder WithParam([NotNull] string key, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);

        /// <summary>
-        /// WithParam (values)
+        /// WithParam: matching on key and values.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="values">The values.</param>
@@ -26,7 +28,16 @@ namespace WireMock.RequestBuilders
        IRequestBuilder WithParam([NotNull] string key, [CanBeNull] params string[] values);

        /// <summary>
-        /// WithParam (funcs)
+        /// WithParam: matching on key, values and matchBehaviour.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="values">The values.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithParam([NotNull] string key, MatchBehaviour matchBehaviour, [CanBeNull] params string[] values);
+
+        /// <summary>
+        /// WithParam: matching on functions.
        /// </summary>
        /// <param name="funcs">The funcs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
--- a/src/WireMock.Net/RequestBuilders/IUrlAndPathRequestBuilder.cs
+++ b/src/WireMock.Net/RequestBuilders/IUrlAndPathRequestBuilder.cs
@@ -10,42 +10,58 @@ namespace WireMock.RequestBuilders
    public interface IUrlAndPathRequestBuilder : IMethodRequestBuilder
    {
        /// <summary>
-        /// The with path.
+        /// WithPath: add path matching based on IStringMatchers.
        /// </summary>
        /// <param name="matchers">The matchers.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithPath([NotNull] params IStringMatcher[] matchers);

        /// <summary>
-        /// The with path.
+        /// WithPath: add path matching based on paths.
        /// </summary>
        /// <param name="paths">The paths.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithPath([NotNull] params string[] paths);

        /// <summary>
-        /// The with path.
+        /// WithPath: add path matching based on paths and matchBehaviour.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithPath(MatchBehaviour matchBehaviour, [NotNull] params string[] paths);
+
+        /// <summary>
+        /// WithPath: add path matching based on functions.
        /// </summary>
        /// <param name="funcs">The path funcs.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithPath([NotNull] params Func<string, bool>[] funcs);

        /// <summary>
-        /// The with url.
+        /// WithUrl: add url matching based on IStringMatcher[].
        /// </summary>
        /// <param name="matchers">The matchers.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithUrl([NotNull] params IStringMatcher[] matchers);

        /// <summary>
-        /// The with url.
+        /// WithUrl: add url matching based on urls.
        /// </summary>
        /// <param name="urls">The urls.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
        IRequestBuilder WithUrl([NotNull] params string[] urls);

        /// <summary>
-        /// The with path.
+        /// WithUrl: add url matching based on urls.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="urls">The urls.</param>
+        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        IRequestBuilder WithUrl(MatchBehaviour matchBehaviour, [NotNull] params string[] urls);
+
+        /// <summary>
+        /// WithUrl: add url matching based on functions.
        /// </summary>
        /// <param name="func">The path func.</param>
        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
--- a/src/WireMock.Net/RequestBuilders/Request.cs
+++ b/src/WireMock.Net/RequestBuilders/Request.cs
@@ -54,11 +54,7 @@ namespace WireMock.RequestBuilders
            return _requestMatchers.Where(rm => rm is T).Cast<T>().FirstOrDefault();
        }

-        /// <summary>
-        /// The with clientIP.
-        /// </summary>
-        /// <param name="matchers">The matchers.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IClientIPRequestBuilder.WithClientIP(IStringMatcher[])"/>
        public IRequestBuilder WithClientIP(params IStringMatcher[] matchers)
        {
            Check.NotNullOrEmpty(matchers, nameof(matchers));
@@ -67,24 +63,22 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// The with clientIP.
-        /// </summary>
-        /// <param name="clientIPs">The ClientIPs.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IClientIPRequestBuilder.WithClientIP(string[])"/>
        public IRequestBuilder WithClientIP(params string[] clientIPs)
+        {
+            return WithClientIP(MatchBehaviour.AcceptOnMatch, clientIPs);
+        }
+
+        /// <inheritdoc cref="IClientIPRequestBuilder.WithClientIP(string[])"/>
+        public IRequestBuilder WithClientIP(MatchBehaviour matchBehaviour, params string[] clientIPs)
        {
            Check.NotNullOrEmpty(clientIPs, nameof(clientIPs));

-            _requestMatchers.Add(new RequestMessageClientIPMatcher(clientIPs));
+            _requestMatchers.Add(new RequestMessageClientIPMatcher(matchBehaviour, clientIPs));
            return this;
        }

-        /// <summary>
-        /// The with clientIP.
-        /// </summary>
-        /// <param name="funcs">The clientIP funcs.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IClientIPRequestBuilder.WithClientIP(Func{string, bool}[])"/>
        public IRequestBuilder WithClientIP(params Func<string, bool>[] funcs)
        {
            Check.NotNullOrEmpty(funcs, nameof(funcs));
@@ -93,11 +87,7 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// The with path.
-        /// </summary>
-        /// <param name="matchers">The matchers.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithPath(IStringMatcher[])"/>
        public IRequestBuilder WithPath(params IStringMatcher[] matchers)
        {
            Check.NotNullOrEmpty(matchers, nameof(matchers));
@@ -106,24 +96,22 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// The with path.
-        /// </summary>
-        /// <param name="paths">The paths.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithPath(string[])"/>
        public IRequestBuilder WithPath(params string[] paths)
+        {
+            return WithPath(MatchBehaviour.AcceptOnMatch, paths);
+        }
+
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithPath(MatchBehaviour, string[])"/>
+        public IRequestBuilder WithPath(MatchBehaviour matchBehaviour, params string[] paths)
        {
            Check.NotNullOrEmpty(paths, nameof(paths));

-            _requestMatchers.Add(new RequestMessagePathMatcher(paths));
+            _requestMatchers.Add(new RequestMessagePathMatcher(matchBehaviour, paths));
            return this;
        }

-        /// <summary>
-        /// The with path.
-        /// </summary>
-        /// <param name="funcs">The path func.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithPath(Func{string, bool}[])"/>
        public IRequestBuilder WithPath(params Func<string, bool>[] funcs)
        {
            Check.NotNullOrEmpty(funcs, nameof(funcs));
@@ -132,11 +120,7 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// The with url.
-        /// </summary>
-        /// <param name="matchers">The matchers.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithUrl(IStringMatcher[])"/>
        public IRequestBuilder WithUrl(params IStringMatcher[] matchers)
        {
            Check.NotNullOrEmpty(matchers, nameof(matchers));
@@ -145,24 +129,22 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// The with url.
-        /// </summary>
-        /// <param name="urls">The urls.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithUrl(string[])"/>
        public IRequestBuilder WithUrl(params string[] urls)
+        {
+            return WithUrl(MatchBehaviour.AcceptOnMatch, urls);
+        }
+
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithUrl(MatchBehaviour, string[])"/>
+        public IRequestBuilder WithUrl(MatchBehaviour matchBehaviour, params string[] urls)
        {
            Check.NotNullOrEmpty(urls, nameof(urls));

-            _requestMatchers.Add(new RequestMessageUrlMatcher(urls));
+            _requestMatchers.Add(new RequestMessageUrlMatcher(matchBehaviour, urls));
            return this;
        }

-        /// <summary>
-        /// The with url.
-        /// </summary>
-        /// <param name="funcs">The url func.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IUrlAndPathRequestBuilder.WithUrl(Func{string, bool}[])"/>
        public IRequestBuilder WithUrl(params Func<string, bool>[] funcs)
        {
            Check.NotNullOrEmpty(funcs, nameof(funcs));
@@ -171,50 +153,50 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingDelete"/>
-        public IRequestBuilder UsingDelete()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingDelete(MatchBehaviour)"/>
+        public IRequestBuilder UsingDelete(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("delete"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "delete"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingGet"/>
-        public IRequestBuilder UsingGet()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingGet(MatchBehaviour)"/>
+        public IRequestBuilder UsingGet(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("get"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "get"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingHead"/>
-        public IRequestBuilder UsingHead()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingHead(MatchBehaviour)"/>
+        public IRequestBuilder UsingHead(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("head"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "head"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingPost"/>
-        public IRequestBuilder UsingPost()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingPost(MatchBehaviour)"/>
+        public IRequestBuilder UsingPost(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("post"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "post"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingPatch"/>
-        public IRequestBuilder UsingPatch()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingPatch(MatchBehaviour)"/>
+        public IRequestBuilder UsingPatch(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("patch"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "patch"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingPut"/>
-        public IRequestBuilder UsingPut()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingPut(MatchBehaviour)"/>
+        public IRequestBuilder UsingPut(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageMethodMatcher("put"));
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, "put"));
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingAnyVerb"/>
-        public IRequestBuilder UsingAnyVerb()
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingAnyMethod"/>
+        public IRequestBuilder UsingAnyMethod()
        {
            var matchers = _requestMatchers.Where(m => m is RequestMessageMethodMatcher).ToList();
            foreach (var matcher in matchers)
@@ -225,33 +207,51 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <inheritdoc cref="IMethodRequestBuilder.UsingVerb"/>
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingAnyVerb"/>
+        public IRequestBuilder UsingAnyVerb()
+        {
+            return UsingAnyMethod();
+        }
+
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingMethod(string[])"/>
+        public IRequestBuilder UsingMethod(params string[] methods)
+        {
+            return UsingMethod(MatchBehaviour.AcceptOnMatch, methods);
+        }
+
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingVerb(string[])"/>
        public IRequestBuilder UsingVerb(params string[] verbs)
        {
-            Check.NotNullOrEmpty(verbs, nameof(verbs));
+            return UsingMethod(verbs);
+        }

-            _requestMatchers.Add(new RequestMessageMethodMatcher(verbs));
+        /// <inheritdoc cref="IMethodRequestBuilder.UsingMethod(MatchBehaviour, string[])"/>
+        public IRequestBuilder UsingMethod(MatchBehaviour matchBehaviour, params string[] methods)
+        {
+            Check.NotNullOrEmpty(methods, nameof(methods));
+
+            _requestMatchers.Add(new RequestMessageMethodMatcher(matchBehaviour, methods));
            return this;
        }

-        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(string)"/>
-        public IRequestBuilder WithBody(string body)
+        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(string, MatchBehaviour)"/>
+        public IRequestBuilder WithBody(string body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageBodyMatcher(body));
+            _requestMatchers.Add(new RequestMessageBodyMatcher(matchBehaviour, body));
            return this;
        }

-        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(byte[])"/>
-        public IRequestBuilder WithBody(byte[] body)
+        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(byte[], MatchBehaviour)"/>
+        public IRequestBuilder WithBody(byte[] body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageBodyMatcher(body));
+            _requestMatchers.Add(new RequestMessageBodyMatcher(matchBehaviour, body));
            return this;
        }

-        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(object)"/>
-        public IRequestBuilder WithBody(object body)
+        /// <inheritdoc cref="IBodyRequestBuilder.WithBody(object, MatchBehaviour)"/>
+        public IRequestBuilder WithBody(object body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageBodyMatcher(body));
+            _requestMatchers.Add(new RequestMessageBodyMatcher(matchBehaviour, body));
            return this;
        }

@@ -291,21 +291,27 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(string)"/>
-        public IRequestBuilder WithParam(string key)
+        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(string, MatchBehaviour)"/>
+        public IRequestBuilder WithParam(string key, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
            Check.NotNull(key, nameof(key));

-            _requestMatchers.Add(new RequestMessageParamMatcher(key));
+            _requestMatchers.Add(new RequestMessageParamMatcher(matchBehaviour, key));
            return this;
        }

        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(string, string[])"/>
        public IRequestBuilder WithParam(string key, params string[] values)
+        {
+            return WithParam(key, MatchBehaviour.AcceptOnMatch, values);
+        }
+
+        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(string, MatchBehaviour, string[])"/>
+        public IRequestBuilder WithParam(string key, MatchBehaviour matchBehaviour, params string[] values)
        {
            Check.NotNull(key, nameof(key));

-            _requestMatchers.Add(new RequestMessageParamMatcher(key, values));
+            _requestMatchers.Add(new RequestMessageParamMatcher(matchBehaviour, key, values));
            return this;
        }

@@ -318,32 +324,39 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string,string,bool)"/>
-        public IRequestBuilder WithHeader(string name, string pattern, bool ignoreCase = true)
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string, string, MatchBehaviour)"/>
+        public IRequestBuilder WithHeader(string name, string pattern, MatchBehaviour matchBehaviour)
+        {
+            return WithHeader(name, pattern, true, matchBehaviour);
+        }
+
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string, string, bool, MatchBehaviour)"/>
+        public IRequestBuilder WithHeader(string name, string pattern, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
            Check.NotNull(name, nameof(name));
            Check.NotNull(pattern, nameof(pattern));

-            _requestMatchers.Add(new RequestMessageHeaderMatcher(name, pattern, ignoreCase));
+            _requestMatchers.Add(new RequestMessageHeaderMatcher(matchBehaviour, name, pattern, ignoreCase));
            return this;
        }

-        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string,string[],bool)"/>
-        public IRequestBuilder WithHeader(string name, string[] patterns, bool ignoreCase = true)
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string, string[], MatchBehaviour)"/>
+        public IRequestBuilder WithHeader(string name, string[] patterns, MatchBehaviour matchBehaviour)
+        {
+            return WithHeader(name, patterns, true, matchBehaviour);
+        }
+
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string, string[], bool, MatchBehaviour)"/>
+        public IRequestBuilder WithHeader(string name, string[] patterns, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
            Check.NotNull(name, nameof(name));
            Check.NotNull(patterns, nameof(patterns));

-            _requestMatchers.Add(new RequestMessageHeaderMatcher(name, patterns, ignoreCase));
+            _requestMatchers.Add(new RequestMessageHeaderMatcher(matchBehaviour, name, patterns, ignoreCase));
            return this;
        }

-        /// <summary>
-        /// With header.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="matchers">The matchers.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(string, IStringMatcher[])"/>
        public IRequestBuilder WithHeader(string name, params IStringMatcher[] matchers)
        {
            Check.NotNull(name, nameof(name));
@@ -353,11 +366,7 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// With header.
-        /// </summary>
-        /// <param name="funcs">The funcs.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithHeader(Func{IDictionary{string, string[]}, bool}[])"/>
        public IRequestBuilder WithHeader(params Func<IDictionary<string, string[]>, bool>[] funcs)
        {
            Check.NotNullOrEmpty(funcs, nameof(funcs));
@@ -366,25 +375,14 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// With cookie.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">if set to <c>true</c> [ignore case].</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-        public IRequestBuilder WithCookie(string name, string pattern, bool ignoreCase = true)
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithCookie(string, string, bool, MatchBehaviour)"/>
+        public IRequestBuilder WithCookie(string name, string pattern, bool ignoreCase = true, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
        {
-            _requestMatchers.Add(new RequestMessageCookieMatcher(name, pattern, ignoreCase));
+            _requestMatchers.Add(new RequestMessageCookieMatcher(matchBehaviour, name, pattern, ignoreCase));
            return this;
        }

-        /// <summary>
-        /// With cookie.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="matchers">The matchers.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithCookie(string, IStringMatcher[])"/>
        public IRequestBuilder WithCookie(string name, params IStringMatcher[] matchers)
        {
            Check.NotNullOrEmpty(matchers, nameof(matchers));
@@ -393,11 +391,7 @@ namespace WireMock.RequestBuilders
            return this;
        }

-        /// <summary>
-        /// With header.
-        /// </summary>
-        /// <param name="funcs">The funcs.</param>
-        /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+        /// <inheritdoc cref="IHeadersAndCookiesRequestBuilder.WithCookie(Func{IDictionary{string, string}, bool}[])"/>
        public IRequestBuilder WithCookie(params Func<IDictionary<string, string>, bool>[] funcs)
        {
            Check.NotNullOrEmpty(funcs, nameof(funcs));
--- a/src/WireMock.Net/RequestMessage.cs
+++ b/src/WireMock.Net/RequestMessage.cs
@@ -34,6 +34,11 @@ namespace WireMock
        /// </summary>
        public string Path { get; }

+        /// <summary>
+        /// Gets the path segments.
+        /// </summary>
+        public string[] PathSegments { get; }
+
        /// <summary>
        /// Gets the method.
        /// </summary>
@@ -60,7 +65,7 @@ namespace WireMock
        public string RawQuery { get; }

        /// <summary>
-        /// The body as string.
+        /// The original body as string, this is defined when Body or BodyAsJson are not null.
        /// </summary>
        public string Body { get; }

@@ -108,7 +113,7 @@ namespace WireMock
        /// <param name="body">The body.</param>
        /// <param name="headers">The headers.</param>
        /// <param name="cookies">The cookies.</param>
-        public RequestMessage([NotNull] Uri url, [NotNull] string method, [NotNull] string clientIP, [CanBeNull] BodyData body, [CanBeNull] IDictionary<string, string[]> headers = null, [CanBeNull] IDictionary<string, string> cookies = null)
+        public RequestMessage([NotNull] Uri url, [NotNull] string method, [NotNull] string clientIP, [CanBeNull] BodyData body = null, [CanBeNull] IDictionary<string, string[]> headers = null, [CanBeNull] IDictionary<string, string> cookies = null)
        {
            Check.NotNull(url, nameof(url));
            Check.NotNull(method, nameof(method));
@@ -120,6 +125,7 @@ namespace WireMock
            Port = url.Port;
            Origin = $"{url.Scheme}://{url.Host}:{url.Port}";
            Path = WebUtility.UrlDecode(url.AbsolutePath);
+            PathSegments = Path.Split('/').Skip(1).ToArray();
            Method = method.ToLower();
            ClientIP = clientIP;

@@ -134,40 +140,6 @@ namespace WireMock
            Query = ParseQuery(RawQuery);
        }

-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestMessage"/> class.
-        /// </summary>
-        /// <param name="url">The original url.</param>
-        /// <param name="method">The HTTP method.</param>
-        /// <param name="clientIP">The client IP Address.</param>
-        /// <param name="bodyAsBytes">The bodyAsBytes byte[].</param>
-        /// <param name="body">The body string.</param>
-        /// <param name="bodyEncoding">The body encoding</param>
-        /// <param name="headers">The headers.</param>
-        /// <param name="cookies">The cookies.</param>
-        public RequestMessage([NotNull] Uri url, [NotNull] string method, [NotNull] string clientIP, [CanBeNull] byte[] bodyAsBytes = null, [CanBeNull] string body = null, [CanBeNull] Encoding bodyEncoding = null, [CanBeNull] IDictionary<string, string[]> headers = null, [CanBeNull] IDictionary<string, string> cookies = null)
-        {
-            Check.NotNull(url, nameof(url));
-            Check.NotNull(method, nameof(method));
-            Check.NotNull(clientIP, nameof(clientIP));
-
-            Url = url.ToString();
-            Protocol = url.Scheme;
-            Host = url.Host;
-            Port = url.Port;
-            Origin = $"{url.Scheme}://{url.Host}:{url.Port}";
-            Path = WebUtility.UrlDecode(url.AbsolutePath);
-            Method = method.ToLower();
-            ClientIP = clientIP;
-            BodyAsBytes = bodyAsBytes;
-            Body = body;
-            BodyEncoding = bodyEncoding;
-            Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
-            Cookies = cookies;
-            RawQuery = WebUtility.UrlDecode(url.Query);
-            Query = ParseQuery(RawQuery);
-        }
-
        private static IDictionary<string, WireMockList<string>> ParseQuery(string queryString)
        {
            if (string.IsNullOrEmpty(queryString))
--- a/src/WireMock.Net/ResponseBuilders/IBodyResponseBuilder.cs
+++ b/src/WireMock.Net/ResponseBuilders/IBodyResponseBuilder.cs
@@ -18,7 +18,6 @@ namespace WireMock.ResponseBuilders
        /// <returns>A <see cref="IResponseBuilder"/>.</returns>
        IResponseBuilder WithBody([NotNull] string body, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);

-
        /// <summary>
        /// WithBody : Create a ... response based on a callback function.
        /// </summary>
@@ -26,8 +25,7 @@ namespace WireMock.ResponseBuilders
        /// <param name="destination">The Body Destination format (SameAsSource, String or Bytes).</param>
        /// <param name="encoding">The body encoding.</param>
        /// <returns>A <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithBody([NotNull] Func<RequestMessage,string> bodyFactory, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);
-
+        IResponseBuilder WithBody([NotNull] Func<RequestMessage, string> bodyFactory, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);

        /// <summary>
        /// WithBody : Create a ... response based on a bytearray.
@@ -43,8 +41,17 @@ namespace WireMock.ResponseBuilders
        /// </summary>
        /// <param name="body">The body.</param>
        /// <param name="encoding">The body encoding.</param>
+        /// <param name="indented">Use JSON indented.</param>
        /// <returns>A <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithBodyAsJson([NotNull] object body, [CanBeNull] Encoding encoding = null);
+        IResponseBuilder WithBodyAsJson([NotNull] object body, [CanBeNull] Encoding encoding = null, bool? indented = null);
+
+        /// <summary>
+        /// WithBody : Create a string response based on a object (which will be converted to a JSON string).
+        /// </summary>
+        /// <param name="body">The body.</param>
+        /// <param name="indented">Define whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.</param>
+        /// <returns>A <see cref="IResponseBuilder"/>.</returns>
+        IResponseBuilder WithBodyAsJson([NotNull] object body, bool indented);

        /// <summary>
        /// WithBody : Create a string response based on a Base64 string (which will be decoded to a normal string).
--- a/src/WireMock.Net/ResponseBuilders/Response.cs
+++ b/src/WireMock.Net/ResponseBuilders/Response.cs
@@ -31,9 +31,6 @@ namespace WireMock.ResponseBuilders
        /// <summary>
        /// Gets a value indicating whether [use transformer].
        /// </summary>
-        /// <value>
-        ///   <c>true</c> if [use transformer]; otherwise, <c>false</c>.
-        /// </value>
        public bool UseTransformer { get; private set; }

        /// <summary>
@@ -258,18 +255,25 @@ namespace WireMock.ResponseBuilders
            return this;
        }

-        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson"/>
-        public IResponseBuilder WithBodyAsJson(object body, Encoding encoding = null)
+        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson(object, Encoding, bool?)"/>
+        public IResponseBuilder WithBodyAsJson(object body, Encoding encoding = null, bool? indented = null)
        {
            Check.NotNull(body, nameof(body));

            ResponseMessage.BodyDestination = null;
            ResponseMessage.BodyAsJson = body;
            ResponseMessage.BodyEncoding = encoding;
+            ResponseMessage.BodyAsJsonIndented = indented;

            return this;
        }

+        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson(object, bool)"/>
+        public IResponseBuilder WithBodyAsJson(object body, bool indented)
+        {
+            return WithBodyAsJson(body, null, indented);
+        }
+
        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyFromBase64"/>
        public IResponseBuilder WithBodyFromBase64(string bodyAsbase64, Encoding encoding = null)
        {
--- a/src/WireMock.Net/ResponseMessage.cs
+++ b/src/WireMock.Net/ResponseMessage.cs
@@ -42,6 +42,11 @@ namespace WireMock
        /// </summary>
        public object BodyAsJson { get; set; }

+        /// <summary>
+        /// Gets or sets a value indicating whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.
+        /// </summary>
+        public bool? BodyAsJsonIndented { get; set; }
+
        /// <summary>
        /// Gets or sets the body as bytes.
        /// </summary>
--- a/src/WireMock.Net/Serialization/MappingConverter.cs
+++ b/src/WireMock.Net/Serialization/MappingConverter.cs
@@ -1,7 +1,5 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using JetBrains.Annotations;
 using WireMock.Admin.Mappings;
 using WireMock.Matchers.Request;
 using WireMock.RequestBuilders;
@@ -96,6 +94,7 @@ namespace WireMock.Serialization
                mappingModel.Response.Headers = null;
                mappingModel.Response.BodyDestination = null;
                mappingModel.Response.BodyAsJson = null;
+                mappingModel.Response.BodyAsJsonIndented = null;
                mappingModel.Response.Body = null;
                mappingModel.Response.BodyAsBytes = null;
                mappingModel.Response.BodyAsFile = null;
@@ -110,6 +109,7 @@ namespace WireMock.Serialization
                mappingModel.Response.StatusCode = response.ResponseMessage.StatusCode;
                mappingModel.Response.Headers = Map(response.ResponseMessage.Headers);
                mappingModel.Response.BodyAsJson = response.ResponseMessage.BodyAsJson;
+                mappingModel.Response.BodyAsJsonIndented = response.ResponseMessage.BodyAsJsonIndented;
                mappingModel.Response.Body = response.ResponseMessage.Body;
                mappingModel.Response.BodyAsBytes = response.ResponseMessage.BodyAsBytes;
                mappingModel.Response.BodyAsFile = response.ResponseMessage.BodyAsFile;
@@ -147,16 +147,14 @@ namespace WireMock.Serialization
            return newDictionary;
        }

+        //private static string[] Map<T>([CanBeNull] IEnumerable<Func<T, bool>> funcs)
+        //{
+        //    return funcs?.Select(Map).Where(x => x != null).ToArray();
+        //}

-
-        private static string[] Map<T>([CanBeNull] IEnumerable<Func<T, bool>> funcs)
-        {
-            return funcs?.Select(Map).Where(x => x != null).ToArray();
-        }
-
-        private static string Map<T>([CanBeNull] Func<T, bool> func)
-        {
-            return func?.ToString();
-        }
+        //private static string Map<T>([CanBeNull] Func<T, bool> func)
+        //{
+        //    return func?.ToString();
+        //}
    }
 }
--- a/src/WireMock.Net/Serialization/MatcherMapper.cs
+++ b/src/WireMock.Net/Serialization/MatcherMapper.cs
@@ -22,11 +22,13 @@ namespace WireMock.Serialization

            string[] patterns = matcher is IStringMatcher stringMatcher ? stringMatcher.GetPatterns() : new string[0];
            bool? ignorecase = matcher is IIgnoreCaseMatcher ignoreCaseMatcher ? ignoreCaseMatcher.IgnoreCase : (bool?)null;
+            bool? rejectOnMatch = matcher.MatchBehaviour == MatchBehaviour.RejectOnMatch ? true : (bool?) null;

            return new MatcherModel
            {
+                RejectOnMatch = rejectOnMatch,
                IgnoreCase = ignorecase,
-                Name = matcher.GetName(),
+                Name = matcher.Name,
                Pattern = patterns.Length == 1 ? patterns.First() : null,
                Patterns = patterns.Length > 1 ? patterns : null
            };
--- a/src/WireMock.Net/Serialization/MatcherModelMapper.cs
+++ b/src/WireMock.Net/Serialization/MatcherModelMapper.cs
@@ -20,23 +20,24 @@ namespace WireMock.Serialization
            string matcherType = parts.Length > 1 ? parts[1] : null;

            string[] patterns = matcher.Patterns ?? new[] { matcher.Pattern };
+            MatchBehaviour matchBehaviour = matcher.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch;

            switch (matcherName)
            {
                case "ExactMatcher":
-                    return new ExactMatcher(patterns);
+                    return new ExactMatcher(matchBehaviour, patterns);

                case "RegexMatcher":
-                    return new RegexMatcher(patterns, matcher.IgnoreCase == true);
+                    return new RegexMatcher(matchBehaviour, patterns, matcher.IgnoreCase == true);

                case "JsonPathMatcher":
-                    return new JsonPathMatcher(patterns);
+                    return new JsonPathMatcher(matchBehaviour, patterns);

                case "XPathMatcher":
-                    return new XPathMatcher(matcher.Pattern);
+                    return new XPathMatcher(matchBehaviour, matcher.Pattern);

                case "WildcardMatcher":
-                    return new WildcardMatcher(patterns, matcher.IgnoreCase == true);
+                    return new WildcardMatcher(matchBehaviour, patterns, matcher.IgnoreCase == true);

                case "SimMetricsMatcher":
                    SimMetricType type = SimMetricType.Levenstein;
@@ -45,7 +46,7 @@ namespace WireMock.Serialization
                        throw new NotSupportedException($"Matcher '{matcherName}' with Type '{matcherType}' is not supported.");
                    }

-                    return new SimMetricsMatcher(matcher.Pattern, type);
+                    return new SimMetricsMatcher(matchBehaviour, matcher.Pattern, type);

                default:
                    throw new NotSupportedException($"Matcher '{matcherName}' is not supported.");
--- a/src/WireMock.Net/Server/FluentMockServer.Admin.cs
+++ b/src/WireMock.Net/Server/FluentMockServer.Admin.cs
@@ -36,8 +36,8 @@ namespace WireMock.Server
        private const string AdminRequests = "/__admin/requests";
        private const string AdminSettings = "/__admin/settings";
        private const string AdminScenarios = "/__admin/scenarios";
-        private readonly RegexMatcher _adminMappingsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/mappings\/(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$");
-        private readonly RegexMatcher _adminRequestsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/requests\/(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$");
+        private readonly RegexMatcher _adminMappingsGuidPathMatcher = new RegexMatcher(MatchBehaviour.AcceptOnMatch, @"^\/__admin\/mappings\/(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$");
+        private readonly RegexMatcher _adminRequestsGuidPathMatcher = new RegexMatcher(MatchBehaviour.AcceptOnMatch, @"^\/__admin\/requests\/(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$");

        private readonly JsonSerializerSettings _settings = new JsonSerializerSettings
        {
@@ -50,7 +50,7 @@ namespace WireMock.Server
        {
            // __admin/settings
            Given(Request.Create().WithPath(AdminSettings).UsingGet()).RespondWith(new DynamicResponseProvider(SettingsGet));
-            Given(Request.Create().WithPath(AdminSettings).UsingVerb("PUT", "POST").WithHeader(HttpKnownHeaderNames.ContentType, ContentTypeJson)).RespondWith(new DynamicResponseProvider(SettingsUpdate));
+            Given(Request.Create().WithPath(AdminSettings).UsingMethod("PUT", "POST").WithHeader(HttpKnownHeaderNames.ContentType, ContentTypeJson)).RespondWith(new DynamicResponseProvider(SettingsUpdate));


            // __admin/mappings
@@ -196,7 +196,7 @@ namespace WireMock.Server
        private void InitProxyAndRecord(IProxyAndRecordSettings settings)
        {
            _httpClientForProxy = HttpClientHelper.CreateHttpClient(settings.ClientX509Certificate2ThumbprintOrSubjectName);
-            Given(Request.Create().WithPath("/*").UsingAnyVerb()).RespondWith(new ProxyAsyncResponseProvider(ProxyAndRecordAsync, settings));
+            Given(Request.Create().WithPath("/*").UsingAnyMethod()).RespondWith(new ProxyAsyncResponseProvider(ProxyAndRecordAsync, settings));
        }

        private async Task<ResponseMessage> ProxyAndRecordAsync(RequestMessage requestMessage, IProxyAndRecordSettings settings)
@@ -225,7 +225,7 @@ namespace WireMock.Server
        {
            var request = Request.Create();
            request.WithPath(requestMessage.Path);
-            request.UsingVerb(requestMessage.Method);
+            request.UsingMethod(requestMessage.Method);

            requestMessage.Query.Loop((key, value) => request.WithParam(key, value.ToArray()));
            requestMessage.Cookies.Loop((key, value) => request.WithCookie(key, value));
@@ -241,7 +241,7 @@ namespace WireMock.Server

            if (requestMessage.Body != null)
            {
-                request.WithBody(new ExactMatcher(requestMessage.Body));
+                request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.Body));
            }

            var response = Response.Create(responseMessage);
@@ -266,17 +266,19 @@ namespace WireMock.Server

        private ResponseMessage SettingsUpdate(RequestMessage requestMessage)
        {
-            var settings = requestMessage.Body != null ? JsonConvert.DeserializeObject<SettingsModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<SettingsModel>();
-
-            if (settings.AllowPartialMapping != null)
-                _options.AllowPartialMapping = settings.AllowPartialMapping.Value;
-
+            var settings = DeserializeObject<SettingsModel>(requestMessage);
            _options.MaxRequestLogCount = settings.MaxRequestLogCount;
-
            _options.RequestLogExpirationDuration = settings.RequestLogExpirationDuration;

+            if (settings.AllowPartialMapping != null)
+            {
+                _options.AllowPartialMapping = settings.AllowPartialMapping.Value;
+            }
+
            if (settings.GlobalProcessingDelay != null)
+            {
                _options.RequestProcessingDelay = TimeSpan.FromMilliseconds(settings.GlobalProcessingDelay.Value);
+            }

            return new ResponseMessage { Body = "Settings updated" };
        }
@@ -303,7 +305,7 @@ namespace WireMock.Server
        {
            Guid guid = Guid.Parse(requestMessage.Path.TrimStart(AdminMappings.ToCharArray()));

-            MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<MappingModel>();
+            var mappingModel = DeserializeObject<MappingModel>(requestMessage);
            DeserializeAndAddOrUpdateMapping(mappingModel, guid);

            return new ResponseMessage { Body = "Mapping added or updated" };
@@ -371,7 +373,7 @@ namespace WireMock.Server
        {
            try
            {
-                MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<MappingModel>();
+                var mappingModel = DeserializeObject<MappingModel>(requestMessage);
                DeserializeAndAddOrUpdateMapping(mappingModel);
            }
            catch (ArgumentException a)
@@ -552,7 +554,7 @@ namespace WireMock.Server
        #region Requests/find
        private ResponseMessage RequestsFind(RequestMessage requestMessage)
        {
-            var requestModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<RequestModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<RequestModel>();
+            var requestModel = DeserializeObject<RequestModel>(requestMessage);

            var request = (Request)InitRequestBuilder(requestModel);

@@ -598,8 +600,7 @@ namespace WireMock.Server

            if (requestModel.ClientIP != null)
            {
-                string clientIP = requestModel.ClientIP as string;
-                if (clientIP != null)
+                if (requestModel.ClientIP is string clientIP)
                {
                    requestBuilder = requestBuilder.WithClientIP(clientIP);
                }
@@ -615,8 +616,7 @@ namespace WireMock.Server

            if (requestModel.Path != null)
            {
-                string path = requestModel.Path as string;
-                if (path != null)
+                if (requestModel.Path is string path)
                {
                    requestBuilder = requestBuilder.WithPath(path);
                }
@@ -632,8 +632,7 @@ namespace WireMock.Server

            if (requestModel.Url != null)
            {
-                string url = requestModel.Url as string;
-                if (url != null)
+                if (requestModel.Url is string url)
                {
                    requestBuilder = requestBuilder.WithUrl(url);
                }
@@ -649,7 +648,7 @@ namespace WireMock.Server

            if (requestModel.Methods != null)
            {
-                requestBuilder = requestBuilder.UsingVerb(requestModel.Methods);
+                requestBuilder = requestBuilder.UsingMethod(requestModel.Methods);
            }

            if (requestModel.Headers != null)
@@ -739,13 +738,18 @@ namespace WireMock.Server
            }
            else if (responseModel.BodyAsJson != null)
            {
-                responseBuilder = responseBuilder.WithBodyAsJson(responseModel.BodyAsJson, ToEncoding(responseModel.BodyEncoding));
+                responseBuilder = responseBuilder.WithBodyAsJson(responseModel.BodyAsJson, ToEncoding(responseModel.BodyEncoding), responseModel.BodyAsJsonIndented == true);
            }
            else if (responseModel.BodyFromBase64 != null)
            {
                responseBuilder = responseBuilder.WithBodyFromBase64(responseModel.BodyFromBase64, ToEncoding(responseModel.BodyEncoding));
            }

+            else if (responseModel.BodyAsFile != null)
+            {
+                responseBuilder = responseBuilder.WithBodyFromFile(responseModel.BodyAsFile);
+            }
+
            if (responseModel.UseTransformer)
            {
                responseBuilder = responseBuilder.WithTransformer();
@@ -768,5 +772,12 @@ namespace WireMock.Server
        {
            return encodingModel != null ? Encoding.GetEncoding(encodingModel.CodePage) : null;
        }
+
+        private T DeserializeObject<T>(RequestMessage requestMessage)
+        {
+            return requestMessage.Body != null ?
+                JsonConvert.DeserializeObject<T>(requestMessage.Body) :
+                ((JObject)requestMessage.BodyAsJson).ToObject<T>();
+        }
    }
 }
--- a/src/WireMock.Net/Server/FluentMockServer.cs
+++ b/src/WireMock.Net/Server/FluentMockServer.cs
@@ -1,20 +1,20 @@
+using JetBrains.Annotations;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Newtonsoft.Json;
+using System.Threading;
 using WireMock.Http;
 using WireMock.Logging;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
+using WireMock.Owin;
 using WireMock.RequestBuilders;
+using WireMock.ResponseProviders;
 using WireMock.Settings;
 using WireMock.Validation;
-using WireMock.Owin;
-using WireMock.ResponseProviders;

 namespace WireMock.Server
 {
@@ -32,7 +32,7 @@ namespace WireMock.Server
        /// Gets a value indicating whether this server is started.
        /// </summary>
        [PublicAPI]
-        public bool IsStarted { get; }
+        public bool IsStarted => _httpServer != null && _httpServer.IsStarted;

        /// <summary>
        /// Gets the ports.
@@ -186,10 +186,23 @@ namespace WireMock.Server

            _httpServer.StartAsync();

-            // Fix for 'Bug: Server not listening after Start() returns (on macOS)'
-            Task.Delay(ServerStartDelay).Wait();
-
-            IsStarted = _httpServer.IsStarted;
+            using (var ctsStartTimeout = new CancellationTokenSource(settings.StartTimeout))
+            {
+                while (!_httpServer.IsStarted)
+                {
+                    // Throw out exception if service start fails
+                    if (_httpServer.RunningException != null)
+                    {
+                        throw new Exception($"Service start failed with error: {_httpServer.RunningException.Message}", _httpServer.RunningException);
+                    }
+                    // Respect start timeout setting by throwing TimeoutException
+                    if (ctsStartTimeout.IsCancellationRequested)
+                    {
+                        throw new TimeoutException($"Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}");
+                    }
+                    ctsStartTimeout.Token.WaitHandle.WaitOne(ServerStartDelay);
+                }
+            }

            if (settings.AllowPartialMapping == true)
            {
@@ -243,7 +256,7 @@ namespace WireMock.Server
        [PublicAPI]
        public void AddCatchAllMapping()
        {
-            Given(Request.Create().WithPath("/*").UsingAnyVerb())
+            Given(Request.Create().WithPath("/*").UsingAnyMethod())
                .WithGuid(Guid.Parse("90008000-0000-4444-a17e-669cd84f1f05"))
                .AtPriority(1000)
                .RespondWith(new DynamicResponseProvider(request => new ResponseMessage { StatusCode = 404, Body = "No matching mapping found" }));
@@ -338,7 +351,7 @@ namespace WireMock.Server
            Check.NotNull(password, nameof(password));

            string authorization = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));
-            _options.AuthorizationMatcher = new RegexMatcher("^(?i)BASIC " + authorization + "$");
+            _options.AuthorizationMatcher = new RegexMatcher(MatchBehaviour.AcceptOnMatch, "^(?i)BASIC " + authorization + "$");
        }

        /// <summary>
--- a/src/WireMock.Net/Transformers/ResponseMessageTransformer.cs
+++ b/src/WireMock.Net/Transformers/ResponseMessageTransformer.cs
@@ -21,7 +21,8 @@ namespace WireMock.Transformers
            var template = new { request = requestMessage };

            // Body
-            string body = bodyIsJson ? JsonConvert.SerializeObject(original.BodyAsJson) : original.Body;
+            Formatting formatting = original.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
+            string body = bodyIsJson ? JsonConvert.SerializeObject(original.BodyAsJson, formatting) : original.Body;
            if (body != null)
            {
                var templateBody = Handlebars.Compile(body);
--- a/src/WireMock.Net/Util/BodyData.cs
+++ b/src/WireMock.Net/Util/BodyData.cs
@@ -13,7 +13,7 @@ namespace WireMock.Util
        public Encoding Encoding { get; set; }

        /// <summary>
-        /// The body as string.
+        /// The body as string, this is defined when BodyAsString or BodyAsJson are not null.
        /// </summary>
        public string BodyAsString { get; set; }

--- a/src/WireMock.Net/Util/BodyParser.cs
+++ b/src/WireMock.Net/Util/BodyParser.cs
@@ -58,6 +58,7 @@ namespace WireMock.Util
            else if (contentTypeHeaderValue != null && contentTypeHeaderValue.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
            {
                var stringData = await ReadStringAsync(stream);
+                data.BodyAsString = stringData.Item1;
                data.Encoding = stringData.Item2;

                try
--- a/src/WireMock.Net/Util/JsonUtils.cs
+++ b/src/WireMock.Net/Util/JsonUtils.cs
@@ -11,8 +11,7 @@ namespace WireMock.Util
                return default(T);
            }

-            var token = value as JToken;
-            return token == null ? default(T) : token.ToObject<T>();
+            return !(value is JToken token) ? default(T) : token.ToObject<T>();
        }
    }
 }
--- a/src/WireMock.Net/WireMock.Net.csproj
+++ b/src/WireMock.Net/WireMock.Net.csproj
@@ -3,7 +3,7 @@
  <PropertyGroup>
    <Description>Lightweight Http Mocking Server for .Net, inspired by WireMock from the Java landscape.</Description>
    <AssemblyTitle>WireMock.Net</AssemblyTitle>
-    <Version>1.0.3.13</Version>
+    <Version>1.0.3.17</Version>
    <Authors>Stef Heyenrath</Authors>
    <TargetFrameworks>net452;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
--- a/test/WireMock.Net.Tests/FluentMockServerTests.cs
+++ b/test/WireMock.Net.Tests/FluentMockServerTests.cs
@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Text;
 using System.Threading.Tasks;
 using NFluent;
 using WireMock.Matchers;
@@ -11,12 +13,14 @@ using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
 using Xunit;
+using Newtonsoft.Json;

 namespace WireMock.Net.Tests
 {
    public partial class FluentMockServerTests : IDisposable
    {
        private FluentMockServer _server;
+        private static string jsonRequestMessage = @"{ ""message"" : ""Hello server"" }";

        // For for AppVeyor + OpenCover
        private string GetCurrentFolder()
@@ -76,6 +80,34 @@ namespace WireMock.Net.Tests
            Check.That(mappings.First().Title).IsNullOrEmpty();
        }

+        [Fact]
+        public void FluentMockServer_ReadStaticMapping_WithResponseBodyFromFile()
+        {
+            string guid = "00000002-ee28-4f29-ae63-1ac9b0802d87";
+
+            string folder = Path.Combine(GetCurrentFolder(), "__admin", "mappings", guid + ".json");
+            string json = File.ReadAllText(folder);
+
+            string responseBodyFilePath = Path.Combine(GetCurrentFolder(), "ResponseBodyFiles", "responsebody.json");
+
+            dynamic jsonObj = JsonConvert.DeserializeObject(json);
+            jsonObj["Response"]["BodyAsFile"] = responseBodyFilePath;
+
+            string output = JsonConvert.SerializeObject(jsonObj, Formatting.Indented);
+            File.WriteAllText(folder, output);
+
+            _server = FluentMockServer.Start();
+            _server.ReadStaticMappingAndAddOrUpdate(folder);
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(1);
+
+            Check.That(mappings.First().RequestMatcher).IsNotNull();
+            Check.That(mappings.First().Provider).IsNotNull();
+            Check.That(mappings.First().Guid).Equals(Guid.Parse(guid));
+            Check.That(mappings.First().Title).IsNullOrEmpty();
+        }
+
        [Fact]
        public void FluentMockServer_ReadStaticMappings()
        {
@@ -85,7 +117,7 @@ namespace WireMock.Net.Tests
            _server.ReadStaticMappings(folder);

            var mappings = _server.Mappings.ToArray();
-            Check.That(mappings).HasSize(2);
+            Check.That(mappings).HasSize(3);
        }

        [Fact]
@@ -189,7 +221,7 @@ namespace WireMock.Net.Tests
            // given
            _server = FluentMockServer.Start();

-            _server.Given(Request.Create().WithPath("/foo").UsingVerb("patch"))
+            _server.Given(Request.Create().WithPath("/foo").UsingMethod("patch"))
                .RespondWith(Response.Create().WithBody("hello patch"));

            // when
@@ -232,6 +264,40 @@ namespace WireMock.Net.Tests
            Check.That(response).IsEqualTo("Hello world!");
        }

+        [Fact]
+        public async Task FluentMockServer_Should_respond_to_request_BodyAsJson()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create().UsingAnyMethod())
+                .RespondWith(Response.Create().WithBodyAsJson(new { message = "Hello" }));
+
+            // Act
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0]);
+
+            // Assert
+            Check.That(response).IsEqualTo("{\"message\":\"Hello\"}");
+        }
+
+        [Fact]
+        public async Task FluentMockServer_Should_respond_to_request_BodyAsJson_Indented()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create().UsingAnyMethod())
+                .RespondWith(Response.Create().WithBodyAsJson(new { message = "Hello" }, true));
+
+            // Act
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0]);
+
+            // Assert
+            Check.That(response).IsEqualTo("{\r\n  \"message\": \"Hello\"\r\n}");
+        }
+
        [Fact]
        public async Task FluentMockServer_Should_respond_to_request_bodyAsCallback()
        {
@@ -285,6 +351,39 @@ namespace WireMock.Net.Tests
            Check.That(responseAsBytes).ContainsExactly(new byte[] { 48, 49 });
        }

+        public static IEnumerable<object[]> ValidMatchersForHelloServerJsonMessage =>
+            new List<object[]>
+            {
+                new object[] { new WildcardMatcher("*Hello server*"), "application/json" },
+                new object[] { new WildcardMatcher("*Hello server*"), "text/plain" },
+                new object[] { new ExactMatcher(jsonRequestMessage), "application/json" },
+                new object[] { new ExactMatcher(jsonRequestMessage), "text/plain" },
+                new object[] { new RegexMatcher("Hello server"), "application/json" },
+                new object[] { new RegexMatcher("Hello server"), "text/plain" },
+                new object[] { new JsonPathMatcher("$..[?(@.message == 'Hello server')]"), "application/json" },
+                new object[] { new JsonPathMatcher("$..[?(@.message == 'Hello server')]"), "text/plain" }
+            };
+
+        [Theory]
+        [MemberData(nameof(ValidMatchersForHelloServerJsonMessage))]
+        public async Task FluentMockServer_Should_respond_to_valid_matchers_when_sent_json(IMatcher matcher, string contentType)
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create().WithPath("/foo").WithBody(matcher))
+                .RespondWith(Response.Create().WithBody("Hello client"));
+
+            // Act
+            var content = new StringContent(jsonRequestMessage, Encoding.UTF8, contentType);
+            var response = await new HttpClient().PostAsync("http://localhost:" + _server.Ports[0] + "/foo", content);
+
+            // Assert
+            var responseString = await response.Content.ReadAsStringAsync();
+            Check.That(responseString).Equals("Hello client");
+        }
+
        [Fact]
        public async Task FluentMockServer_Should_respond_404_for_unexpected_request()
        {
@@ -482,10 +581,28 @@ namespace WireMock.Net.Tests
            Check.That(response).IsEqualTo("/fooBar");
        }

+        [Fact]
+        public async Task FluentMockServer_Should_IgnoreRestrictedHeader()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+            _server
+                .Given(Request.Create().WithPath("/head").UsingHead())
+                .RespondWith(Response.Create().WithHeader("Content-Length", "1024"));
+
+            var request = new HttpRequestMessage(HttpMethod.Head, "http://localhost:" + _server.Ports[0] + "/head");
+
+            // Act
+            var response = await new HttpClient().SendAsync(request);
+
+            // Assert
+            Check.That(response.Content.Headers.GetValues("Content-Length")).ContainsExactly("0");
+        }
+
        public void Dispose()
        {
            _server?.Stop();
            _serverForProxyForwarding?.Stop();
        }
    }
-}
+}
--- a/test/WireMock.Net.Tests/MatchBehaviourHelperTests.cs
+++ b/test/WireMock.Net.Tests/MatchBehaviourHelperTests.cs
@@ -0,0 +1,25 @@
+using NFluent;
+using WireMock.Matchers;
+using Xunit;
+
+namespace WireMock.Net.Tests
+{
+    public class MatchBehaviourHelperTests
+    {
+        [Fact]
+        public void MatchBehaviourHelper_Convert_AcceptOnMatch()
+        {
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.AcceptOnMatch, 0.0)).IsEqualTo(0.0);
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.AcceptOnMatch, 0.5)).IsEqualTo(0.5);
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.AcceptOnMatch, 1.0)).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void MatchBehaviourHelper_Convert_RejectOnMatch()
+        {
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.RejectOnMatch, 0.0)).IsEqualTo(1.0);
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.RejectOnMatch, 0.5)).IsEqualTo(0.0);
+            Check.That(MatchBehaviourHelper.Convert(MatchBehaviour.RejectOnMatch, 1.0)).IsEqualTo(0.0);
+        }
+    }
+}
--- a/test/WireMock.Net.Tests/Matchers/ExactMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/ExactMatcherTests.cs
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new ExactMatcher("X");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("ExactMatcher");
@@ -46,7 +46,7 @@ namespace WireMock.Net.Tests.Matchers
        }

        [Fact]
-        public void Request_WithBodyExactMatcher_false()
+        public void ExactMatcher_IsMatch_SinglePattern()
        {
            // Assign
            var matcher = new ExactMatcher("cat");
@@ -55,7 +55,33 @@ namespace WireMock.Net.Tests.Matchers
            double result = matcher.IsMatch("caR");

            // Assert
-            Check.That(result).IsStrictlyLessThan(1.0);
+            Check.That(result).IsEqualTo(0.0);
+        }
+
+        [Fact]
+        public void ExactMatcher_IsMatch_SinglePattern_AcceptOnMatch()
+        {
+            // Assign
+            var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, "cat");
+
+            // Act
+            double result = matcher.IsMatch("cat");
+
+            // Assert
+            Check.That(result).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void ExactMatcher_IsMatch_SinglePattern_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new ExactMatcher(MatchBehaviour.RejectOnMatch, "cat");
+
+            // Act
+            double result = matcher.IsMatch("cat");
+
+            // Assert
+            Check.That(result).IsEqualTo(0.0);
        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/ExactObjectMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/ExactObjectMatcherTests.cs
@@ -14,10 +14,52 @@ namespace WireMock.Net.Tests.Matchers

            // Act
            var matcher = new ExactObjectMatcher(obj);
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("ExactObjectMatcher");
        }
+
+        [Fact]
+        public void ExactObjectMatcher_IsMatch_ByteArray()
+        {
+            // Assign
+            object checkValue = new byte[] { 1, 2 };
+
+            // Act
+            var matcher = new ExactObjectMatcher(new byte[] { 1, 2 });
+            double result = matcher.IsMatch(checkValue);
+
+            // Assert
+            Check.That(result).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void ExactObjectMatcher_IsMatch_AcceptOnMatch()
+        {
+            // Assign
+            object obj = 1;
+
+            // Act
+            var matcher = new ExactObjectMatcher(obj);
+            double result = matcher.IsMatch(1);
+
+            // Assert
+            Check.That(result).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void ExactObjectMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            object obj = 1;
+
+            // Act
+            var matcher = new ExactObjectMatcher(MatchBehaviour.RejectOnMatch, obj);
+            double result = matcher.IsMatch(1);
+
+            // Assert
+            Check.That(result).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/JsonPathMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/JsonPathMatcherTests.cs
@@ -14,7 +14,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new JsonPathMatcher("X");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("JsonPathMatcher");
@@ -78,10 +78,10 @@ namespace WireMock.Net.Tests.Matchers
        public void JsonPathMatcher_IsMatch_Object_Exception_Mismatch()
        {
            // Assign
-            var matcher = new JsonPathMatcher("xxx");
+            var matcher = new JsonPathMatcher("");

            // Act 
-            double match = matcher.IsMatch("");
+            double match = matcher.IsMatch("x");

            // Assert 
            Check.That(match).IsEqualTo(0);
@@ -131,5 +131,18 @@ namespace WireMock.Net.Tests.Matchers
            // Assert 
            Check.That(match).IsEqualTo(1);
        }
+
+        [Fact]
+        public void JsonPathMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new JsonPathMatcher(MatchBehaviour.RejectOnMatch, "$..[?(@.Id == 1)]");
+
+            // Act
+            double match = matcher.IsMatch(JObject.Parse("{\"Id\":1,\"Name\":\"Test\"}"));
+
+            // Assert
+            Check.That(match).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/RegexMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/RegexMatcherTests.cs
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new RegexMatcher("");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("RegexMatcher");
@@ -32,6 +32,18 @@ namespace WireMock.Net.Tests.Matchers
            Check.That(patterns).ContainsExactly("X");
        }

+        [Fact]
+        public void RegexMatcher_GetIgnoreCase()
+        {
+            // Act
+            bool case1 = new RegexMatcher("X").IgnoreCase;
+            bool case2 = new RegexMatcher("X", true).IgnoreCase;
+
+            // Assert
+            Check.That(case1).IsFalse();
+            Check.That(case2).IsTrue();
+        }
+
        [Fact]
        public void RegexMatcher_IsMatch()
        {
@@ -65,10 +77,23 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new RegexMatcher("H.*o", true);

            // Act
-            double result = matcher.IsMatch("hello world!");
+            double result = matcher.IsMatch("hello");

            // Assert
            Check.That(result).IsEqualTo(1.0d);
        }
+
+        [Fact]
+        public void RegexMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new RegexMatcher(MatchBehaviour.RejectOnMatch, "h.*o");
+
+            // Act
+            double result = matcher.IsMatch("hello");
+
+            // Assert
+            Check.That(result).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/SimMetricsMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/SimMetricsMatcherTests.cs
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new SimMetricsMatcher("X");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("SimMetricsMatcher.Levenstein");
@@ -57,5 +57,31 @@ namespace WireMock.Net.Tests.Matchers
            // Assert
            Check.That(result).IsStrictlyLessThan(0.1).And.IsStrictlyGreaterThan(0.05);
        }
+
+        [Fact]
+        public void SimMetricsMatcher_IsMatch_AcceptOnMatch()
+        {
+            // Assign
+            var matcher = new SimMetricsMatcher("test");
+
+            // Act
+            double result = matcher.IsMatch("test");
+
+            // Assert
+            Check.That(result).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void SimMetricsMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new SimMetricsMatcher(MatchBehaviour.RejectOnMatch, "test");
+
+            // Act
+            double result = matcher.IsMatch("test");
+
+            // Assert
+            Check.That(result).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/WildcardMatcherTest.cs
+++ b/test/WireMock.Net.Tests/Matchers/WildcardMatcherTest.cs
@@ -65,7 +65,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new WildcardMatcher("x");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("WildcardMatcher");
@@ -83,5 +83,17 @@ namespace WireMock.Net.Tests.Matchers
            // Assert
            Check.That(patterns).ContainsExactly("x");
        }
+
+        [Fact]
+        public void WildcardMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new WildcardMatcher(MatchBehaviour.RejectOnMatch, "m");
+
+            // Act
+            double result = matcher.IsMatch("m");
+
+            Check.That(result).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/Matchers/XPathMatcherTests.cs
+++ b/test/WireMock.Net.Tests/Matchers/XPathMatcherTests.cs
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.Matchers
            var matcher = new XPathMatcher("X");

            // Act
-            string name = matcher.GetName();
+            string name = matcher.Name;

            // Assert
            Check.That(name).Equals("XPathMatcher");
@@ -31,5 +31,39 @@ namespace WireMock.Net.Tests.Matchers
            // Assert
            Check.That(patterns).ContainsExactly("X");
        }
+
+        [Fact]
+        public void XPathMatcher_IsMatch_AcceptOnMatch()
+        {
+            // Assign
+            string xml = @"
+                    <todo-list>
+                        <todo-item id='a1'>abc</todo-item>
+                    </todo-list>";
+            var matcher = new XPathMatcher("/todo-list[count(todo-item) = 1]");
+
+            // Act
+            double result = matcher.IsMatch(xml);
+
+            // Assert
+            Check.That(result).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void XPathMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            string xml = @"
+                    <todo-list>
+                        <todo-item id='a1'>abc</todo-item>
+                    </todo-list>";
+            var matcher = new XPathMatcher(MatchBehaviour.RejectOnMatch, "/todo-list[count(todo-item) = 1]");
+
+            // Act
+            double result = matcher.IsMatch(xml);
+
+            // Assert
+            Check.That(result).IsEqualTo(0.0);
+        }
    }
 }
--- a/test/WireMock.Net.Tests/RequestCookieTests.cs
+++ b/test/WireMock.Net.Tests/RequestCookieTests.cs
@@ -15,10 +15,10 @@ namespace WireMock.Net.Tests
        public void Request_WithCookie_OK()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithCookie("session", "a*");
+            var spec = Request.Create().UsingAnyMethod().WithCookie("session", "a*");

            // when
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, null, null, null, null, new Dictionary<string, string> { { "session", "abc" } });
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, null, null, new Dictionary<string, string> { { "session", "abc" } });

            // then
            var requestMatchResult = new RequestMatchResult();
--- a/test/WireMock.Net.Tests/RequestMatchers/RequestMessageBodyMatcherTests.cs
+++ b/test/WireMock.Net.Tests/RequestMatchers/RequestMessageBodyMatcherTests.cs
@@ -0,0 +1,172 @@
+using System;
+using Moq;
+using NFluent;
+using WireMock.Matchers;
+using WireMock.Matchers.Request;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.RequestMatchers
+{
+    public class RequestMessageBodyMatcherTests
+    {
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "b"
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch("b"), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = new byte[] { 1 }
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Never);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 }
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Never);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_and_BodyAsString_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 },
+                BodyAsString = "orig"
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IObjectMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = 42
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(42), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IObjectMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = new byte[] { 1 }
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(It.IsAny<byte[]>()), Times.Once);
+        }
+    }
+}
--- a/test/WireMock.Net.Tests/RequestMatchers/RequestMessageCookieMatcherTests.cs
+++ b/test/WireMock.Net.Tests/RequestMatchers/RequestMessageCookieMatcherTests.cs
@@ -9,6 +9,99 @@ namespace WireMock.Net.Tests.RequestMatchers
 {
    public class RequestMessageCookieMatcherTests
    {
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_AcceptOnMatch_CookieDoesNotExists()
+        {
+            // Assign
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1");
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.AcceptOnMatch, "c", "x");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+        }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_RejectOnMatch_CookieDoesNotExists()
+        {
+            // Assign
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1");
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.RejectOnMatch, "c", "x");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_AcceptOnMatch_CookieDoesNotMatchPattern()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "c", "x" } };
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.AcceptOnMatch, "no-match", "123");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+        }
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_RejectOnMatch_CookieDoesNotMatchPattern()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "h", "x" } };
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.RejectOnMatch, "no-match", "123");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_AcceptOnMatch()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "h", "x" } };
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.AcceptOnMatch, "h", "x");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_RejectOnMatch()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "h", "x" } };
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.RejectOnMatch, "h", "x");
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+        }
+
        [Fact]
        public void RequestMessageCookieMatcher_GetMatchingScore_IStringMatcher_Match()
        {
--- a/test/WireMock.Net.Tests/RequestMatchers/RequestMessageHeaderMatcherTests.cs
+++ b/test/WireMock.Net.Tests/RequestMatchers/RequestMessageHeaderMatcherTests.cs
@@ -9,11 +9,104 @@ namespace WireMock.Net.Tests.RequestMatchers
 {
    public class RequestMessageHeaderMatcherTests
    {
+        [Fact]
+        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotExists()
+        {
+            // Assign
+            var requestMessage = new RequestMessage(new Uri("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);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+        }
+
+        [Fact]
+        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotExists()
+        {
+            // Assign
+            var requestMessage = new RequestMessage(new Uri("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);
+
+            // 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 Uri("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);
+
+            // 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 Uri("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);
+
+            // 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 Uri("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);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch()
+        {
+            // Assign
+            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+            var requestMessage = new RequestMessage(new Uri("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);
+
+            // 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 headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", null, headers);
            var matcher = new RequestMessageHeaderMatcher("h", new ExactMatcher("x"));

--- a/test/WireMock.Net.Tests/RequestMatchers/RequestMessageParamMatcherTests.cs
+++ b/test/WireMock.Net.Tests/RequestMatchers/RequestMessageParamMatcherTests.cs
@@ -1,5 +1,6 @@
 using System;
 using NFluent;
+using WireMock.Matchers;
 using WireMock.Matchers.Request;
 using Xunit;

@@ -12,7 +13,7 @@ namespace WireMock.Net.Tests.RequestMatchers
        {
            // Assign
            var requestMessage = new RequestMessage(new Uri("http://localhost?key=test1,test2"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageParamMatcher("key", new[] { "test1", "test2" });
+            var matcher = new RequestMessageParamMatcher(MatchBehaviour.AcceptOnMatch, "key", new[] { "test1", "test2" });

            // Act
            var result = new RequestMatchResult();
@@ -27,7 +28,7 @@ namespace WireMock.Net.Tests.RequestMatchers
        {
            // Assign
            var requestMessage = new RequestMessage(new Uri("http://localhost?key=test0,test2"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageParamMatcher("key", new[] { "test1", "test2" });
+            var matcher = new RequestMessageParamMatcher(MatchBehaviour.AcceptOnMatch, "key", new[] { "test1", "test2" });

            // Act
            var result = new RequestMatchResult();
@@ -42,7 +43,7 @@ namespace WireMock.Net.Tests.RequestMatchers
        {
            // Assign
            var requestMessage = new RequestMessage(new Uri("http://localhost?key"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageParamMatcher("key", new[] { "test1", "test2" });
+            var matcher = new RequestMessageParamMatcher(MatchBehaviour.AcceptOnMatch, "key", new[] { "test1", "test2" });

            // Act
            var result = new RequestMatchResult();
@@ -57,7 +58,7 @@ namespace WireMock.Net.Tests.RequestMatchers
        {
            // Assign
            var requestMessage = new RequestMessage(new Uri("http://localhost?key"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageParamMatcher("key");
+            var matcher = new RequestMessageParamMatcher(MatchBehaviour.AcceptOnMatch, "key");

            // Act
            var result = new RequestMatchResult();
@@ -72,7 +73,7 @@ namespace WireMock.Net.Tests.RequestMatchers
        {
            // Assign
            var requestMessage = new RequestMessage(new Uri("http://localhost?key"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageParamMatcher("key", new string[] { });
+            var matcher = new RequestMessageParamMatcher(MatchBehaviour.AcceptOnMatch, "key", new string[] { });

            // Act
            var result = new RequestMatchResult();
--- a/test/WireMock.Net.Tests/RequestMessageTests.cs
+++ b/test/WireMock.Net.Tests/RequestMessageTests.cs
@@ -1,5 +1,6 @@
 using System;
 using NFluent;
+using WireMock.Util;
 using Xunit;

 namespace WireMock.Net.Tests
@@ -50,5 +51,25 @@ namespace WireMock.Net.Tests
            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 Uri("http://localhost/a/b/c"), "POST", ClientIp);
+
+            // Assert
+            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+        }
+
+        [Fact]
+        public void RequestMessage_Constructor2_PathSegments()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
+
+            // Assert
+            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+        }
    }
 }
--- a/test/WireMock.Net.Tests/RequestTests.cs
+++ b/test/WireMock.Net.Tests/RequestTests.cs
@@ -5,6 +5,7 @@ using NFluent;
 using Xunit;
 using WireMock.RequestBuilders;
 using WireMock.Matchers.Request;
+using WireMock.Util;

 namespace WireMock.Net.Tests
 {
@@ -30,12 +31,14 @@ namespace WireMock.Net.Tests
        public void Should_exclude_requests_not_matching_given_headers()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "tatata");
+            var spec = Request.Create().UsingAnyMethod().WithHeader("X-toto", "tatata");

            // when
-            string bodyAsString = "whatever";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "whatever"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -46,12 +49,14 @@ namespace WireMock.Net.Tests
        public void Should_exclude_requests_not_matching_given_headers_ignorecase()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "abc", false);
+            var spec = Request.Create().UsingAnyMethod().WithHeader("X-toto", "abc", false);

            // when
-            string bodyAsString = "whatever";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "ABC" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "whatever"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, new Dictionary<string, string[]> { { "X-toto", new[] { "ABC" } } });

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -62,47 +67,50 @@ namespace WireMock.Net.Tests
        public void Should_specify_requests_matching_given_header_prefix()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "tata*");
+            var spec = Request.Create().UsingAnyMethod().WithHeader("X-toto", "tata*");

            // when
-            string bodyAsString = "whatever";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "TaTa" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "whatever"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, new Dictionary<string, string[]> { { "X-toto", new[] { "TaTa" } } });

            // then
            var requestMatchResult = new RequestMatchResult();
            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
        }

-        
-
        [Fact]
        public void Should_specify_requests_matching_given_body()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody("Hello world!");
+            var spec = Request.Create().UsingAnyMethod().WithBody("Hello world!");

            // when
-            string bodyAsString = "Hello world!";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "Hello world!"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
        }

-        
        [Fact]
        public void Should_exclude_requests_not_matching_given_body()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody("      Hello world!   ");
+            var spec = Request.Create().UsingAnyMethod().WithBody("      Hello world!   ");

            // when
-            string bodyAsString = "xxx";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "xxx"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -127,7 +135,7 @@ namespace WireMock.Net.Tests
        public void Should_specify_requests_matching_given_param_func()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithParam(p => p.ContainsKey("bar"));
+            var spec = Request.Create().UsingAnyMethod().WithParam(p => p.ContainsKey("bar"));

            // when
            var request = new RequestMessage(new Uri("http://localhost/foo?bar=1&bar=2"), "PUT", ClientIp);
--- a/test/WireMock.Net.Tests/RequestWithBodyTests.cs
+++ b/test/WireMock.Net.Tests/RequestWithBodyTests.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Text;
 using Newtonsoft.Json;
 using NFluent;
@@ -19,7 +18,7 @@ namespace WireMock.Net.Tests
        public void Request_WithBody_FuncString()
        {
            // Assign
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(b => b.Contains("b"));
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody(b => b.Contains("b"));

            // Act
            var body = new BodyData
@@ -37,7 +36,7 @@ namespace WireMock.Net.Tests
        public void Request_WithBody_FuncJson()
        {
            // Assign
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(b => b != null);
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody(b => b != null);

            // Act
            var body = new BodyData
@@ -55,7 +54,7 @@ namespace WireMock.Net.Tests
        public void Request_WithBody_FuncByteArray()
        {
            // Assign
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody((byte[] b) => b != null);
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody((byte[] b) => b != null);

            // Act
            var body = new BodyData
@@ -73,12 +72,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyExactMatcher()
        {
            // given
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new ExactMatcher("cat"));
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody(new ExactMatcher("cat"));

            // when
-            string bodyAsString = "cat";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "cat"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -89,12 +90,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyWildcardMatcher()
        {
            // given
-            var spec = Request.Create().WithPath("/foo").UsingAnyVerb().WithBody(new WildcardMatcher("H*o*"));
+            var spec = Request.Create().WithPath("/foo").UsingAnyMethod().WithBody(new WildcardMatcher("H*o*"));

            // when
-            string bodyAsString = "Hello world!";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "tatata" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "Hello world!"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -105,17 +108,19 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyXPathMatcher_true()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 3]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 3]"));

            // when
-            string xmlBodyAsString = @"
+            var body = new BodyData
+            {
+                BodyAsString = @"
                    <todo-list>
                        <todo-item id='a1'>abc</todo-item>
                        <todo-item id='a2'>def</todo-item>
                        <todo-item id='a3'>xyz</todo-item>
-                    </todo-list>";
-            byte[] body = Encoding.UTF8.GetBytes(xmlBodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, xmlBodyAsString, Encoding.UTF8);
+                    </todo-list>"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -126,17 +131,19 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyXPathMatcher_false()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 99]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 99]"));

            // when
-            string xmlBodyAsString = @"
+            var body = new BodyData
+            {
+                BodyAsString = @"
                    <todo-list>
                        <todo-item id='a1'>abc</todo-item>
                        <todo-item id='a2'>def</todo-item>
                        <todo-item id='a3'>xyz</todo-item>
-                    </todo-list>";
-            byte[] body = Encoding.UTF8.GetBytes(xmlBodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, xmlBodyAsString, Encoding.UTF8);
+                    </todo-list>"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -147,12 +154,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyJsonPathMatcher_true()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$..things[?(@.name == 'RequiredThing')]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new JsonPathMatcher("$..things[?(@.name == 'RequiredThing')]"));

            // when
-            string bodyAsString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -163,12 +172,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyJsonPathMatcher_false()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$.things[?(@.name == 'RequiredThing')]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new JsonPathMatcher("$.things[?(@.name == 'RequiredThing')]"));

            // when
-            string bodyAsString = "{ \"things\": { \"name\": \"Wiremock\" } }";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "{ \"things\": { \"name\": \"Wiremock\" } }"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -179,13 +190,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyAsJson_Object_JsonPathMatcher_true()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$..things[?(@.name == 'RequiredThing')]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new JsonPathMatcher("$..things[?(@.name == 'RequiredThing')]"));

            // when
            string jsonString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }";
            var bodyData = new BodyData
            {
                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                BodyAsString = jsonString,
                Encoding = Encoding.UTF8
            };

@@ -195,17 +207,19 @@ namespace WireMock.Net.Tests
            var requestMatchResult = new RequestMatchResult();
            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
        }
+
        [Fact]
        public void Request_WithBodyAsJson_Array_JsonPathMatcher_1()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$..books[?(@.price < 10)]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new JsonPathMatcher("$..books[?(@.price < 10)]"));

            // when
            string jsonString = "{ \"books\": [ { \"category\": \"test1\", \"price\": 8.95 }, { \"category\": \"test2\", \"price\": 20 } ] }";
            var bodyData = new BodyData
            {
                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                BodyAsString = jsonString,
                Encoding = Encoding.UTF8
            };

@@ -220,13 +234,14 @@ namespace WireMock.Net.Tests
        public void Request_WithBodyAsJson_Array_JsonPathMatcher_2()
        {
            // given
-            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$..[?(@.Id == 1)]"));
+            var spec = Request.Create().UsingAnyMethod().WithBody(new JsonPathMatcher("$..[?(@.Id == 1)]"));

            // when
            string jsonString = "{ \"Id\": 1, \"Name\": \"Test\" }";
            var bodyData = new BodyData
            {
                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                BodyAsString = jsonString,
                Encoding = Encoding.UTF8
            };

@@ -243,7 +258,7 @@ namespace WireMock.Net.Tests
        {
            // Assign
            object body = DateTime.MinValue;
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(body);
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody(body);

            var bodyData = new BodyData
            {
@@ -263,7 +278,7 @@ namespace WireMock.Net.Tests
        {
            // Assign
            byte[] body = { 123 };
-            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(body);
+            var requestBuilder = Request.Create().UsingAnyMethod().WithBody(body);

            var bodyData = new BodyData
            {
--- a/test/WireMock.Net.Tests/RequestWithPathTests.cs
+++ b/test/WireMock.Net.Tests/RequestWithPathTests.cs
@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
 using NFluent;
 using WireMock.Matchers;
 using Xunit;
 using WireMock.RequestBuilders;
 using WireMock.Matchers.Request;
+using WireMock.Util;

 namespace WireMock.Net.Tests
 {
@@ -17,12 +17,14 @@ namespace WireMock.Net.Tests
        public void Request_WithPath_WithHeader_Match()
        {
            // given
-            var spec = Request.Create().WithPath("/foo").UsingAnyVerb().WithHeader("X-toto", "tata");
+            var spec = Request.Create().WithPath("/foo").UsingAnyMethod().WithHeader("X-toto", "tata");

            // when
-            string bodyAsString = "whatever";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp, body, new Dictionary<string, string[]> { { "X-toto", new[] { "tata" } } });

            // then
            var requestMatchResult = new RequestMatchResult();
@@ -105,9 +107,11 @@ namespace WireMock.Net.Tests
            var spec = Request.Create().WithPath("/foo").UsingDelete();

            // when
-            string bodyAsString = "whatever";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "Delete", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "whatever"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "Delete", ClientIp, body);

            // then
            var requestMatchResult = new RequestMatchResult();
--- a/test/WireMock.Net.Tests/ResponseBodyFiles/responsebody.json
+++ b/test/WireMock.Net.Tests/ResponseBodyFiles/responsebody.json
@@ -0,0 +1,3 @@
+{
+  "test": "test"
+}
--- a/test/WireMock.Net.Tests/ResponseBuilderTests/ResponseWithBodyHandlebarsTests.cs
+++ b/test/WireMock.Net.Tests/ResponseBuilderTests/ResponseWithBodyHandlebarsTests.cs
@@ -41,9 +41,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_Handlebars_UrlPathVerb()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "whatever"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            var response = Response.Create()
                .WithBody("test {{request.url}} {{request.path}} {{request.method}}")
@@ -60,9 +62,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_Handlebars_Query()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body);

            var response = Response.Create()
                .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
@@ -79,9 +83,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_Handlebars_Header()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });

            var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();

@@ -98,9 +104,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_Handlebars_Headers()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });

            var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();

@@ -118,9 +126,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_Handlebars_Origin_Port_Protocol_Host()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost:1234"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost:1234"), "POST", ClientIp, body);

            var response = Response.Create()
                .WithBody("test {{request.origin}} {{request.port}} {{request.protocol}} {{request.host}}")
--- a/test/WireMock.Net.Tests/ResponseBuilderTests/ResponseWithBodyTests.cs
+++ b/test/WireMock.Net.Tests/ResponseBuilderTests/ResponseWithBodyTests.cs
@@ -3,6 +3,7 @@ using System.Text;
 using System.Threading.Tasks;
 using NFluent;
 using WireMock.ResponseBuilders;
+using WireMock.Util;
 using Xunit;

 namespace WireMock.Net.Tests.ResponseBuilderTests
@@ -15,9 +16,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_String()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);

@@ -34,9 +37,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_Bytes()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);

@@ -53,9 +58,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_WithBody_String_Encoding()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            var response = Response.Create().WithBody("test", null, Encoding.ASCII);

@@ -71,9 +78,11 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
        public async Task Response_ProvideResponse_WithBody_Object_Encoding()
        {
            // given
-            string bodyAsString = "abc";
-            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
-            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+            var body = new BodyData
+            {
+                BodyAsString = "abc"
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body);

            object x = new { value = "test" };
            var response = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
@@ -137,7 +146,7 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
            // Assert
            Check.That(responseMessage.Body).IsNull();
            Check.That(responseMessage.BodyAsBytes).IsNull();
-            Check.That(((dynamic) responseMessage.BodyAsJson).value).Equals(42);
+            Check.That(((dynamic)responseMessage.BodyAsJson).value).Equals(42);
            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
        }
    }
--- a/test/WireMock.Net.Tests/ResponseTests.cs
+++ b/test/WireMock.Net.Tests/ResponseTests.cs
@@ -0,0 +1,26 @@
+using System;
+using NFluent;
+using WireMock.ResponseBuilders;
+using Xunit;
+
+namespace WireMock.Net.Tests
+{
+    public class ResponseTests
+    {
+        private const string ClientIp = "::1";
+
+        [Fact]
+        public async void Response_Create_WithHeader_ContentLength()
+        {
+            // Assign
+            var requestMock = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp);
+            IResponseBuilder builder = Response.Create().WithHeader("Content-Length", "1024");
+
+            // Act
+            var response = await builder.ProvideResponseAsync(requestMock);
+
+            // Assert
+            Check.That(response.Headers["Content-Length"].ToString()).Equals("1024");
+        }
+    }
+}
--- a/test/WireMock.Net.Tests/Serialization/MatcherMapperTests.cs
+++ b/test/WireMock.Net.Tests/Serialization/MatcherMapperTests.cs
@@ -47,7 +47,7 @@ namespace WireMock.Net.Tests.Serialization
        {
            // Assign
            var matcherMock = new Mock<IStringMatcher>();
-            matcherMock.Setup(m => m.GetName()).Returns("test");
+            matcherMock.Setup(m => m.Name).Returns("test");
            matcherMock.Setup(m => m.GetPatterns()).Returns(new[] { "p1", "p2" });

            // Act
--- a/test/WireMock.Net.Tests/WireMock.Net.Tests.csproj
+++ b/test/WireMock.Net.Tests/WireMock.Net.Tests.csproj
@@ -31,9 +31,15 @@
  </ItemGroup>

  <ItemGroup>
+    <None Update="ResponseBodyFiles\responsebody.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
    <None Update="__admin\mappings\00000002-ee28-4f29-ae63-1ac9b0802d86.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
+    <None Update="__admin\mappings\00000002-ee28-4f29-ae63-1ac9b0802d87.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
    <None Update="__admin\mappings\documentdb_root.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
--- a/test/WireMock.Net.Tests/__admin/mappings/00000002-ee28-4f29-ae63-1ac9b0802d87.json
+++ b/test/WireMock.Net.Tests/__admin/mappings/00000002-ee28-4f29-ae63-1ac9b0802d87.json
@@ -0,0 +1,24 @@
+{
+  "Guid": "00000002-ee28-4f29-ae63-1ac9b0802d87",
+  "Priority": 0,
+  "Request": {
+    "Path": {
+      "Matchers": [
+        {
+          "Name": "ExactMatcher",
+          "Pattern": "/response/staticfile"
+        }
+      ]
+    },
+    "Methods": [
+      "get"
+    ]
+  },
+  "Response": {
+    "StatusCode": 200,
+    "BodyAsFile": "responsebody.json",
+    "Headers": {
+      "Content-Type": "application/json"
+    }
+  }
+}
Author	SHA1	Message	Date
Stef Heyenrath	538d04e440	Changelog for 1.0.3.17	2018-05-16 22:30:25 +02:00
Alastair Crabtree	c575ca8296	Merge pull request #138 from WireMock-Net/stef_negate_matcher Added Negate matcher logic	2018-05-16 20:19:48 +01:00
Stef Heyenrath	d0e76b3dbe	Merge into the stef_negate_matcher branch (solves issue #133 ) (#135 ) * Fixed #133 * tests: add parametrised tests that cover various body matchers for json * Code review comments (BodyAsStringOriginal) * tests: minor method name change	2018-05-15 12:41:07 +02:00
Alastair Crabtree	a8ddd31c9c	Stef negate matcher (#134 ) * RejectOnMatch (wip) * RejectOnMatch (wip) * RejectOnMatch (wip) * RejectOnMatch (wip) * docs: improve sample app matcher to show use of reject on match * Reworked code review comments	2018-05-12 12:51:56 +02:00
Stef Heyenrath	d3640d065e	Reworked code review comments	2018-05-12 12:45:58 +02:00
Alastair Crabtree	9d6df1c7c8	docs: improve sample app matcher to show use of reject on match	2018-05-12 01:19:01 +01:00
Stef Heyenrath	ca5056aed3	RejectOnMatch (wip)	2018-05-06 10:40:42 +02:00
Stef Heyenrath	e7319a202a	RejectOnMatch (wip)	2018-05-04 20:27:39 +02:00
Stef Heyenrath	8959e55ca3	RejectOnMatch (wip)	2018-05-04 08:16:42 +02:00
Stef Heyenrath	0fb4b62b50	RejectOnMatch (wip)	2018-05-03 16:59:31 +02:00
Stef Heyenrath	7cf283ec13	Restricted ResponseHeaders (#126 )	2018-04-17 19:43:38 +02:00
Stef Heyenrath	2c0f00d77f	Release notes	2018-04-15 14:04:08 +02:00
Stef Heyenrath	1bcdfe31ab	1.0.3.16	2018-04-15 14:02:45 +02:00
raghavendrabankapur	0abe12f5c8	Fix for issue #118 (#121 ) * Fix for issue #118 * Adding test cases for fix #118 * Moved the namespace in using block for fix #118	2018-04-15 11:25:17 +02:00
SubjectiveReality	7bd63a0baf	Change listen from loopback to any ip address for dotnetcore2.0 apps per issue #124 Change listen from loopback to any ip address for dotnetcore2.0 apps per issue #124 (#125)	2018-04-14 09:56:29 +02:00
Stef Heyenrath	a29363105c	1.0.3.15	2018-04-05 21:07:05 +02:00
Stef Heyenrath	4f294baff2	Small code refactor (#117 )	2018-04-05 20:51:10 +02:00
Evan Liang	2d2a2dd6fc	Respect start timeout setting and expose exception from server startup (#117 ) * Respect start timeout setting and expose exception from server startup * Dispose running servers properly on error happening * Addressed comments from Stef	2018-04-05 18:31:10 +00:00
Stef Heyenrath	ac72973cc4	1.0.3.14	2018-04-01 11:54:20 +02:00
Stef Heyenrath	e87f970057	PathSegments (#114 )	2018-03-29 08:51:22 +02:00
Stef Heyenrath	df4a1f628a	BodyAsJsonIndented (#113 )	2018-03-28 09:51:01 +02:00
Stef Heyenrath	bdb79aec95	Add some more RequestMessageBodyMatcherTests (#112 )	2018-03-28 08:18:33 +02:00