au.com.dius.pact.core.model.InteractionSpec ‑ interactions do conflict if their requests are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do conflict if their responses are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if their descriptions are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if their provider states are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if they are equal

au.com.dius.pact.core.matchers.ContentTypeMatcherSpec ‑ matching binary data where content type does not match
au.com.dius.pact.core.matchers.ContentTypeMatcherSpec ‑ matching binary data where content type matches
au.com.dius.pact.core.matchers.ContentTypeMatcherSpec ‑ matching binary data with a text format like JSON
au.com.dius.pact.core.matchers.DiffUtilsKtSpec ‑ generates a diff of JSON
au.com.dius.pact.core.matchers.EachValueMatcherSpec ‑ matching json bodies - return no mismatches - with each like matcher on unequal lists
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ correctly uses a matcher when there are repeated values [actualBody: PRESENT(c=1&a=b&c=3000), expectedBody: PRESENT(a=b&c=2), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ delegates to any defined matcher [actualBody: PRESENT(a=b&c=2), expectedBody: PRESENT(c=1&a=b), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ handles delimiters in the values [actualBody: PRESENT(a=b&c=1=2), expectedBody: PRESENT(c=1&a=b), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - if the same key is repeated with values in different order [actualBody: PRESENT(a=2&a=1&b=3), expectedBody: PRESENT(a=1&a=2&b=3), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - if the same key is repeated with values missing [actualBody: PRESENT(a=1&a=2), expectedBody: PRESENT(a=1&a=2&a=3), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the actual body contains keys that are not in the expected body and we do not allow extra keys [actualBody: PRESENT(a=b&c=d), expectedBody: PRESENT(c=d), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the actual body contains values that are not the same as the expected body [actualBody: PRESENT(a=b&c=1), expectedBody: PRESENT(c=d&a=b), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the expected body contains keys that are not in the actual body [actualBody: PRESENT(a=b), expectedBody: PRESENT(a=b&c=d), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the expected body contains less values than the actual body [actualBody: PRESENT(a=b&a=c), expectedBody: PRESENT(a=b), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the expected body contains more values than the actual body [actualBody: PRESENT(a=b&c=2), expectedBody: PRESENT(c=1&a=b&c=3000), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns mismatches - when the expected body is present but there is no actual body [actualBody: MISSING, expectedBody: PRESENT(a=a), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns no mismatches - when the actual body has extra keys and we allow unexpected keys [actualBody: PRESENT(a=b&c=d), expectedBody: PRESENT(a=b), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns no mismatches - when the expected body and actual bodies are empty [actualBody: EMPTY, expectedBody: EMPTY, #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns no mismatches - when the expected body and actual bodies are equal [actualBody: PRESENT(a=b&c=d), expectedBody: PRESENT(a=b&c=d), #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns no mismatches - when the expected body is missing [actualBody: EMPTY, expectedBody: MISSING, #0]
au.com.dius.pact.core.matchers.FormPostContentMatcherSpec ‑ returns no mismatches - when the keys are in different order [actualBody: PRESENT(a=b&c=d), expectedBody: PRESENT(c=d&a=b), #0]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - applies the matching rule to all header values
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - be false when headers are not equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - be true when headers are equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - combines mismatches if there are multiple
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be false when charsets are not equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be false when headers are not equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be false when other parameters are not equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be true when headers are equal
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be true when headers are equal but have different case
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - be true when the charset is missing from the expected header
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - content type header - delegate to any defined matcher
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - delegate to a matcher when one is defined
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ matching headers - exclude whitespace from the comparison
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ parse parameters - parse the parameters into a map
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str:  , expected:  , #1]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: , expected: , #0]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: abc , xyz, expected: abc ,xyz, #6]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: abc xyz, expected: abc xyz, #3]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: abc, expected: abc, #2]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: abc, xyz, expected: abc,xyz, #5]
au.com.dius.pact.core.matchers.HeaderMatcherSpec ‑ strip whitespace test [str: abc,xyz, expected: abc,xyz, #4]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return a mismatch - with ignore-order - when actual has extra elements [expected: [1,2,3], actual: [1,2,3,4], message: [1, 2, 3, 4], #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return a mismatch - with ignore-order - when actual has extra elements [expected: [{"i":"a"},{"i":"b"},{"i":"c"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"},{"i":"d"}], message: [{"i":"a"}, {"i":"b"}, {"i":"c"}, {"i":"d"}], #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - when comparing a missing body to anything [actualBody: PRESENT("Blah"), expectedBody: MISSING, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - when comparing empty bodies [actualBody: EMPTY, expectedBody: EMPTY, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - with each like matcher on empty list [actualBody: PRESENT({"list": []}), expectedBody: PRESENT({"list": [100]}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - with each like matcher on unequal lists [actualBody: PRESENT({"list": [100, 200, 300, 400]}), expectedBody: PRESENT({"list": [100]}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal Lists [actualBody: PRESENT([100,200,300]), expectedBody: PRESENT([100, 200, 300]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal Maps [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({"something":100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal bodies [actualBody: PRESENT("Blah"), expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a list to one with with different size
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a map to a list [actualBody: PRESENT([100, 100]), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a map to one with less entries [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing an empty list to a non-empty one [actualBody: PRESENT([100]), expectedBody: PRESENT([]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing an empty map to a non-empty one and we do not
         allow unexpected keys [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing anything to a null body [actualBody: PRESENT(""), expectedBody: NULL, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing anything to an empty body [actualBody: EMPTY, expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing list to anything [actualBody: PRESENT(100), expectedBody: PRESENT([100, 100]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when the actual body has invalid value [actualBody: PRESENT({"something": 101}), expectedBody: PRESENT({"something": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns a mismatch - when the actual body is missing a key [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - returns no mismatch - when comparing an empty map to a non-empty one [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with a Values matcher defined - and when the actual body is missing a key, not be a mismatch [actualBody: PRESENT({"something": 100, "other": 100}), expectedBody: PRESENT({"somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with a matcher defined - delegate to the matcher [actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({"something": 101}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with a matcher defined - matching a list at the root with extra fields [actualBody: PRESENT([
        {
            "documentId": 0,
            "documentCategoryId": 5,
            "documentCategoryCode": null,
            "contentLength": 0,
            "tags": null
        },
        {
            "documentId": 1,
            "documentCategoryId": 5,
            "documentCategoryCode": null,
            "contentLength": 0,
            "tags": null
        }
    ]), expectedBody: PRESENT([{
      "name": "Test",
      "documentId": 0,
      "documentCategoryId": 5,
      "contentLength": 0
    }]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when actual is missing an element [expected: [1, 2, 3], actual: [2, 1, 5], #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when actual is missing an element [expected: [{"i":"a"}, {"i":"b"}, {"i":"c"}], actual: [{"i":"b"}, {"i":"a"}, {"i":"d"}], #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when inorder defaults on other list [actualBody: PRESENT({
     "array1": [{"foo": "a"},{"foo": "b"}],
     "array2": [2, 3, 1, 4]
     }), expectedBody: PRESENT({
     "array1": [{"foo": "b"},{"foo": "a"}],
     "array2": [1, 2, 3, 4]
     }), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return mismatches on nested lists when overriding equality
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on array that is value in key/value pair [item: $.array1, actual: {"array1": ["red", "blue"]}, expected: {"array1": ["blue", "red"]}, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on array that is value in key/value pair [item: $.array1, actual: {"array1": [{"foo": "a"},{"foo": "b"}]}, expected: {"array1": [{"foo": "b"},{"foo": "a"}]}, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on nested lists
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: ["a", "b", "c", "d"], actual: ["c", "a", "b", "d"], #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [1, "b", 3, "d"], actual: ["d", 1, 3, "b"], #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [1, 2, 3, 4], actual: [2, 3, 1, 4], #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [{"i": "a"}, {"i": 2}, {"i": "c"}], actual: [{"i": 2}, {"i": "c"}, {"i": "a"}], #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - return no mismatches [expected: ["a","A"], actual: ["B","b"], match: true, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - return no mismatches [expected: ["a","A"], actual: ["b","B"], match: true, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - returns a mismatch when multiple of the same element
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"down"}], matches: true, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"up"}], matches: true, #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"b", "status":"down"},{"id":"a", "status":"up"}], matches: true, #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"down"}], matches: false, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"a", "status":"up"}, "4", {"id":"b", "status":"down"}], matches: false, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"a", "status":"up"}, 4, {"id":"b", "status":"down"}], matches: true, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"down"}, {"id":"a", "status":"up"}, 5], matches: true, #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"up"}, {"id":"a", "status":"down"}, 5], matches: false, #4]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"up"}, {"id":"a", "status":"up"}, 5], matches: true, #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"c", "status":"up"}, {"id":"a", "status":"up"}, 5], matches: false, #5]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"down"}], matches: true, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"up"}], matches: true, #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"down"},{"id":"c", "status":"up"}], matches: false, #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"down"}], matches: false, #4]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"up"}], matches: true, #5]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"b", "status":"down"}], matches: true, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"c", "status":"up"}], matches: true, #6]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"c", "status":"up"},{"id":"b", "status":"up"}], matches: true, #7]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with max-equals-ignore-order - return a mismatch when actual has extra elements [expected: [1,2], actual: [1,2,3,4,5,6], message: [1, 2, 3, 4, 5, 6] (size 6), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with max-equals-ignore-order - return a mismatch when actual has extra elements [expected: [{"i":"a"},{"i":"b"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"},{"i":"d"}], message: [{"i":"a"}, {"i":"b"}, {"i":"c"}, {"i":"d"}] (size 4), #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 200, 100, 200, 400], matches: false, min: 7, #6]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 200, 100, 200, 400], matches: true, min: 5, #4]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 300, 100, 200, 400], matches: false, min: 5, #5]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200], actual: [100, 200, 100, 400], matches: true, min: 3, #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 100, 100, 400], matches: true, min: 2, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 100, 400], matches: true, min: 2, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 200, 400], matches: false, min: 2, #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - return equality mismatch [actualBody: PRESENT([200, 100, 300, 400]), expectedBody: PRESENT([50]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - return type mismatch on bad type [actualBody: PRESENT([200, 100, "bad", 300]), expectedBody: PRESENT([100]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - specific index matcher overrides wildcard [actualBody: PRESENT(["2", 5, 5, 5, 5]), expectedBody: PRESENT([1, "2", 3]), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [1,2,3], match: true, #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [1,3,4], match: false, #2]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [2,1,3], match: true, #1]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [{"i":"a"},{"i":"b"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"}], match: true, #3]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ returns a mismatch - when comparing maps with different keys and wildcard matching is disabled [actualBody: PRESENT({"id": 100, "width": 100}), expectedBody: PRESENT({"id": 100, "height": 100}), #0]
au.com.dius.pact.core.matchers.JsonContentMatcherSpec ‑ returns no mismatch - when comparing maps with different keys and Value matcher is enabled [actualBody: PRESENT({"id": 100, "width": 100}), expectedBody: PRESENT({"id": 100, "height": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return a mismatch - with ignore-order - when actual has extra elements [expected: [1,2,3], actual: [1,2,3,4], message: [1, 2, 3, 4], #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return a mismatch - with ignore-order - when actual has extra elements [expected: [{"i":"a"},{"i":"b"},{"i":"c"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"},{"i":"d"}], message: [{"i":"a"}, {"i":"b"}, {"i":"c"}, {"i":"d"}], #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - when comparing a missing body to anything [actualBody: PRESENT(11 bytes starting with 000000000122426c616822...), expectedBody: MISSING, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - when comparing empty bodies [actualBody: EMPTY, expectedBody: EMPTY, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - with each like matcher on empty list [actualBody: PRESENT(17 bytes starting with 00000000017b226c697374223a205b5d...), expectedBody: PRESENT({"list": [100]}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - with each like matcher on unequal lists [actualBody: PRESENT(35 bytes starting with 00000000017b226c697374223a205b31...), expectedBody: PRESENT({"list": [100]}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal Lists [actualBody: PRESENT(18 bytes starting with 00000000015b3130302c3230302c3330...), expectedBody: PRESENT([100, 200, 300]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal Maps [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"something":100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - return no mismatches - with equal bodies [actualBody: PRESENT(11 bytes starting with 000000000122426c616822...), expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a list to one with with different size
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a map to a list [actualBody: PRESENT(15 bytes starting with 00000000015b3130302c203130305d...), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing a map to one with less entries [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing an empty list to a non-empty one [actualBody: PRESENT(10 bytes starting with 00000000015b3130305d...), expectedBody: PRESENT([]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing an empty map to a non-empty one and we do not
         allow unexpected keys [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing anything to a null body [actualBody: PRESENT(7 bytes starting with 00000000012222...), expectedBody: NULL, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing anything to an empty body [actualBody: EMPTY, expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when comparing list to anything [actualBody: PRESENT(8 bytes starting with 0000000001313030...), expectedBody: PRESENT([100, 100]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when the actual body has invalid value [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"something": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns a mismatch - when the actual body is missing a key [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"something": 100, "somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - returns no mismatch - when comparing an empty map to a non-empty one [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with a Values matcher defined - and when the actual body is missing a key, not be a mismatch [actualBody: PRESENT(37 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"somethingElse": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with a matcher defined - delegate to the matcher [actualBody: PRESENT(23 bytes starting with 00000000017b22736f6d657468696e67...), expectedBody: PRESENT({"something": 101}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with a matcher defined - matching a list at the root with extra fields [actualBody: PRESENT(?????[
        {
            "documentId": 0,
            "documentCategoryId": 5,
            "documentCategoryCode": null,
            "contentLength": 0,
            "tags": null
        },
        {
            "documentId": 1,
            "documentCategoryId": 5,
            "documentCategoryCode": null,
            "contentLength": 0,
            "tags": null
        }
    ]), expectedBody: PRESENT([{
      "name": "Test",
      "documentId": 0,
      "documentCategoryId": 5,
      "contentLength": 0
    }]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when actual is missing an element [expected: [1, 2, 3], actual: [2, 1, 5], #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when actual is missing an element [expected: [{"i":"a"}, {"i":"b"}, {"i":"c"}], actual: [{"i":"b"}, {"i":"a"}, {"i":"d"}], #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return a mismatch when inorder defaults on other list [actualBody: PRESENT(85 bytes starting with 00000000017b0a202020202022617272...), expectedBody: PRESENT({
     "array1": [{"foo": "b"},{"foo": "a"}],
     "array2": [1, 2, 3, 4]
     }), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return mismatches on nested lists when overriding equality
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on array that is value in key/value pair [item: $.array1, actual: {"array1": ["red", "blue"]}, expected: {"array1": ["blue", "red"]}, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on array that is value in key/value pair [item: $.array1, actual: {"array1": [{"foo": "a"},{"foo": "b"}]}, expected: {"array1": [{"foo": "b"},{"foo": "a"}]}, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches on nested lists
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: ["a", "b", "c", "d"], actual: ["c", "a", "b", "d"], #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [1, "b", 3, "d"], actual: ["d", 1, 3, "b"], #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [1, 2, 3, 4], actual: [2, 3, 1, 4], #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order - return no mismatches when comparing lists [expected: [{"i": "a"}, {"i": 2}, {"i": "c"}], actual: [{"i": 2}, {"i": "c"}, {"i": "a"}], #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - return no mismatches [expected: ["a","A"], actual: ["B","b"], match: true, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - return no mismatches [expected: ["a","A"], actual: ["b","B"], match: true, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order and regex - returns a mismatch when multiple of the same element
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"down"}], matches: true, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"up"}], matches: true, #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"b", "status":"down"},{"id":"a", "status":"up"}], matches: true, #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"down"}], matches: false, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"a", "status":"up"}, "4", {"id":"b", "status":"down"}], matches: false, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"a", "status":"up"}, 4, {"id":"b", "status":"down"}], matches: true, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"down"}, {"id":"a", "status":"up"}, 5], matches: true, #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"up"}, {"id":"a", "status":"down"}, 5], matches: false, #4]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"b", "status":"up"}, {"id":"a", "status":"up"}, 5], matches: true, #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements with unique ids plus numbers [actual: [{"id":"c", "status":"up"}, {"id":"a", "status":"up"}, 5], matches: false, #5]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"down"}], matches: true, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"a", "status":"up"},{"id":"b", "status":"up"}], matches: true, #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"down"},{"id":"c", "status":"up"}], matches: false, #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"down"}], matches: false, #4]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"a", "status":"up"}], matches: true, #5]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"b", "status":"down"}], matches: true, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"b", "status":"up"},{"id":"c", "status":"up"}], matches: true, #6]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with ignore-order, addtnl matchers - and elements without unique ids [actual: [{"id":"c", "status":"up"},{"id":"b", "status":"up"}], matches: true, #7]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with max-equals-ignore-order - return a mismatch when actual has extra elements [expected: [1,2], actual: [1,2,3,4,5,6], message: [1, 2, 3, 4, 5, 6] (size 6), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with max-equals-ignore-order - return a mismatch when actual has extra elements [expected: [{"i":"a"},{"i":"b"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"},{"i":"d"}], message: [{"i":"a"}, {"i":"b"}, {"i":"c"}, {"i":"d"}] (size 4), #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 200, 100, 200, 400], matches: false, min: 7, #6]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 200, 100, 200, 400], matches: true, min: 5, #4]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200, 200, 300], actual: [100, 300, 300, 100, 200, 400], matches: false, min: 5, #5]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100, 200], actual: [100, 200, 100, 400], matches: true, min: 3, #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 100, 100, 400], matches: true, min: 2, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 100, 400], matches: true, min: 2, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - and multiple of the same element [expected: [100, 100], actual: [100, 200, 400], matches: false, min: 2, #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - return equality mismatch [actualBody: PRESENT(25 bytes starting with 00000000015b3230302c203130302c20...), expectedBody: PRESENT([50]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - return type mismatch on bad type [actualBody: PRESENT(27 bytes starting with 00000000015b3230302c203130302c20...), expectedBody: PRESENT([100]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order - specific index matcher overrides wildcard [actualBody: PRESENT(22 bytes starting with 00000000015b2232222c20352c20352c...), expectedBody: PRESENT([1, "2", 3]), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [1,2,3], match: true, #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [1,3,4], match: false, #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [1,2], actual: [2,1,3], match: true, #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies - with min-equals-ignore-order type matching - when actual has extra elements [expected: [{"i":"a"},{"i":"b"}], actual: [{"i":"a"},{"i":"b"},{"i":"c"}], match: true, #3]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies with missing magic bytes - return mismatches - with equal bodies [actual: "Blah", expected: "Blah", actualBody: PRESENT("Blah"), expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies with missing magic bytes - return mismatches - with equal bodies [actual: [100,200,300], expected: [100,200,300], actualBody: PRESENT([100,200,300]), expectedBody: PRESENT([100,200,300]), #2]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ matching json bodies with missing magic bytes - return mismatches - with equal bodies [actual: {"something": 100}, expected: {"something": 100}, actualBody: PRESENT({"something": 100}), expectedBody: PRESENT({"something": 100}), #1]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ returns a mismatch - when comparing maps with different keys and wildcard matching is disabled [actualBody: PRESENT(30 bytes starting with 00000000017b226964223a203130302c...), expectedBody: PRESENT({"id": 100, "height": 100}), #0]
au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcherSpec ‑ returns no mismatch - when comparing maps with different keys and Value matcher is enabled [actualBody: PRESENT(30 bytes starting with 00000000017b226964223a203130302c...), expectedBody: PRESENT({"id": 100, "height": 100}), #0]
au.com.dius.pact.core.matchers.MatcherExecutorKtSpec ‑ match regex [regex: look|look_bordered|slider_cta, actual: look_bordered, result: [], #0]
au.com.dius.pact.core.matchers.MatcherExecutorKtSpec ‑ match semver [actual: 04.5.7, result: [HeaderMismatch(headerKey=test, expected=, actual=04.5.7, mismatch='04.5.7' is not a valid semantic version)], #2]
au.com.dius.pact.core.matchers.MatcherExecutorKtSpec ‑ match semver [actual: 4.5.7, result: [], #0]
au.com.dius.pact.core.matchers.MatcherExecutorKtSpec ‑ match semver [actual: 4.5.7, result: [], #3]
au.com.dius.pact.core.matchers.MatcherExecutorKtSpec ‑ match semver [actual: 4.5.7.8, result: [HeaderMismatch(headerKey=test, expected=, actual=4.5.7.8, mismatch='4.5.7.8' is not a valid semantic version)], #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 100 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 100 -> 200.3
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 100 -> true
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 2.3 -> 2.3
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 2.3 -> 2.300
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 200 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - 200 -> null
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - <?xml version="1.0" encoding="UTF-8"?><a/>
 -> <?xml version="1.0" encoding="UTF-8"?><a/>

au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - <?xml version="1.0" encoding="UTF-8"?><a/>
 -> v="bool"
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - <?xml version="1.0" encoding="UTF-8"?><a/>
 -> v="true"
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - Harry -> Some other string
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - [100, 200, 300] -> [200.3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - [a:100] -> [a:200.3, b:200, c:300]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - hello -> hello
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - null -> null
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ boolean matcher test - true -> false
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ date matcher [expected: 01-01-1970, actual: 01011970, pattern: dd-MM-yyyy, mustBeEmpty: false, matcher: DateMatcher(format=dd-MM-yyyy), #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ date matcher [expected: 01-01-1970, actual: 14-01-2000, pattern: null, mustBeEmpty: true, matcher: DateMatcher(format=yyyy-MM-dd), #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ date matcher [expected: 12/30/1970, actual: 01/14/2001, pattern: MM/dd/yyyy, mustBeEmpty: true, matcher: DateMatcher(format=MM/dd/yyyy), #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ date matcher [expected: 2014-01-01, actual: null, pattern: null, mustBeEmpty: false, matcher: DateMatcher(format=yyyy-MM-dd), #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display 55 as 55
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display <?xml version="1.0" encoding="UTF-8"?><foo xmlns="a"/>
 as <{a}foo>
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display <?xml version="1.0" encoding="UTF-8"?><foo/>
 as <foo>
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display <?xml version="1.0" encoding="UTF-8"?><foo>
  <bar/>
</foo>
 as <foo>
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display [#text: text] as 'text'
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display foo as 'foo'
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ display null as null
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equality matching produces a message on mismatch
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 100, actual: 100, mustBeEmpty: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 100, actual: 100, mustBeEmpty: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 100, actual: 100, mustBeEmpty: true, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 100, actual: 100, mustBeEmpty: true, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 100, actual: null, mustBeEmpty: false, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 2.3, actual: 2.3, mustBeEmpty: true, #16]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 2.3, actual: 2.3, mustBeEmpty: true, #17]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 2.3, actual: 2.300, mustBeEmpty: true, #18]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: 2.3, actual: 2.300, mustBeEmpty: true, #19]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a/>
, mustBeEmpty: true, #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b/>
, mustBeEmpty: false, #11]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b:e xmlns:b="a"/>
, mustBeEmpty: true, #13]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, mustBeEmpty: true, #12]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><e xmlns="b"/>
, mustBeEmpty: false, #14]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: hello, actual: hello, mustBeEmpty: true, #15]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: null, actual: 100, mustBeEmpty: false, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: null, actual: null, mustBeEmpty: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: null, actual: null, mustBeEmpty: true, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: null, actual: null, mustBeEmpty: true, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ equals matcher matches using equals [expected: null, actual: null, mustBeEmpty: true, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: 100, actual: 2010023, mustBeEmpty: true, matcher: IncludeMatcher(value=100), #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: BobHarry, mustBeEmpty: true, matcher: IncludeMatcher(value=Harry), #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: BobHarryGeorge, mustBeEmpty: true, matcher: IncludeMatcher(value=Harry), #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: Harry, mustBeEmpty: true, matcher: IncludeMatcher(value=Harry), #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: HarryBob, mustBeEmpty: true, matcher: IncludeMatcher(value=Harry), #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: Tom, mustBeEmpty: false, matcher: IncludeMatcher(value=Harry), #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ include matcher matches if the expected is included in the actual [expected: Harry, actual: null, mustBeEmpty: false, matcher: IncludeMatcher(value=Harry), #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - <au.com.dius.pact.core.model.matchingrules.TypeMatcher@1603dc2f>
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MaxTypeMatcher(max=1)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MaxTypeMatcher(max=2)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MinMaxTypeMatcher(min=1, max=2)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MinMaxTypeMatcher(min=2, max=3)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MinTypeMatcher(min=1)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ list type matcher matches on array sizes - MinTypeMatcher(min=2)
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 0, result: false, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 0, result: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 0, result: true, #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100, result: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100, result: false, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100, result: false, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100, result: false, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100, result: false, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100.0, result: true, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100.0, result: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching decimal number values [value: 100.0, result: true, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 0, result: true, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 0, result: true, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100, result: true, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100.0, result: false, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ matching integer values [value: 100x, result: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 100, actual: 200, mustBeEmpty: true, #21]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 100, actual: 200.3, mustBeEmpty: true, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 2.3, actual: 2.3, mustBeEmpty: true, #22]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 2.3, actual: 2.300, mustBeEmpty: true, #23]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 200, actual: 200, mustBeEmpty: false, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: 200, actual: null, mustBeEmpty: false, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a/>
, mustBeEmpty: true, #15]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b/>
, mustBeEmpty: false, #16]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b:e xmlns:b="a"/>
, mustBeEmpty: true, #18]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, mustBeEmpty: true, #17]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><e xmlns="b"/>
, mustBeEmpty: false, #19]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: Harry, actual: , mustBeEmpty: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: Harry, actual: , mustBeEmpty: false, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: Harry, actual: Some other string, mustBeEmpty: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: [100, 200, 300], actual: [200.3], mustBeEmpty: true, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: [100, 200, 300], actual: [], mustBeEmpty: false, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: [a:100], actual: [:], mustBeEmpty: false, #11]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: [a:100], actual: [a:200.3, b:200, c:300], mustBeEmpty: true, #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: hello, actual: hello, mustBeEmpty: true, #20]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: null, actual: null, mustBeEmpty: true, #12]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: null, actual: null, mustBeEmpty: true, #13]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: null, actual: null, mustBeEmpty: true, #14]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: null, actual: null, mustBeEmpty: true, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ notEmpty matcher test [expected: true, actual: false, mustBeEmpty: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100, actual: 2.3, mustBeEmpty: true, #25]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100, actual: 2.300, mustBeEmpty: true, #24]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: 200, mustBeEmpty: false, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: 200.3, mustBeEmpty: true, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: Some other string, mustBeEmpty: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: [200.3], mustBeEmpty: false, #17]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: [a:200.3, b:200, c:300], mustBeEmpty: false, #20]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: false, mustBeEmpty: false, #11]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: DECIMAL, expected: 100.0, actual: null, mustBeEmpty: false, #14]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: 200, mustBeEmpty: true, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: 200, mustBeEmpty: true, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: 200.3, mustBeEmpty: false, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: Some other string, mustBeEmpty: false, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: [200.3], mustBeEmpty: false, #16]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: [a:200.3, b:200, c:300], mustBeEmpty: false, #19]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: false, mustBeEmpty: false, #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: INTEGER, expected: 100, actual: null, mustBeEmpty: false, #13]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: 2.3, mustBeEmpty: true, #23]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: 2.300, mustBeEmpty: true, #22]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: 200, mustBeEmpty: true, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: 200.3, mustBeEmpty: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: Some other string, mustBeEmpty: false, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: [200.3], mustBeEmpty: false, #18]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: [a:200.3, b:200, c:300], mustBeEmpty: false, #21]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: false, mustBeEmpty: false, #12]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ number type matcher matches on types [numberType: NUMBER, expected: 100, actual: null, mustBeEmpty: false, #15]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: 100, actual: 20123, regex: \d+, mustBeEmpty: true, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: 100, actual: 20123, regex: \d+, mustBeEmpty: true, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: Harry, actual: Happy, regex: Ha[a-z]*, mustBeEmpty: true, #0]

au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: Harry, actual: null, regex: Ha[a-z]*, mustBeEmpty: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: harry100, actual: 20123happy, regex: [a-z0-9]+, mustBeEmpty: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: issue1316, actual: null, regex: [a-z0-9]*, mustBeEmpty: false, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ regex matcher matches using the provided regex [expected: issue1316, actual: null, regex: [a-z0-9]+, mustBeEmpty: false, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ semver matcher test [expected: 1.0.0, actual: 1.0, mustBeEmpty: false, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ semver matcher test [expected: 1.0.0, actual: 1.0.0, mustBeEmpty: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ semver matcher test [expected: 1.0.0, actual: 1.0.10-beta.3, mustBeEmpty: true, #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ semver matcher test [expected: 1.0.0, actual: Not a version, mustBeEmpty: false, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 100 -> 199
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 100 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 200 -> 100
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 200 -> 199
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 200 -> 299
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 200 -> 401
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 201 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 201 -> 204
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 300 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 300 -> 399
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 400 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 400 -> 499
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 500 -> 200
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 500 -> 250
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 500 -> 504
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ status code matcher test - 500 -> 599
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ time matcher [expected: 00:00, actual: 14:01:02, pattern: mm:ss, mustBeEmpty: false, matcher: TimeMatcher(format=mm:ss), #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ time matcher [expected: 00:00:14, actual: 05:10:14, pattern: ss:mm:HH, mustBeEmpty: true, matcher: TimeMatcher(format=ss:mm:HH), #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ time matcher [expected: 14:00:00+10:00, actual: null, pattern: null, mustBeEmpty: false, matcher: TimeMatcher(format=HH:mm:ss), #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ time matcher [expected: 14:00:00, actual: 14:00:00, pattern: null, mustBeEmpty: true, matcher: TimeMatcher(format=HH:mm:ss), #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2014-01-01 14:00:00+10:00, actual: 2013#12#01#14#00#00, pattern: yyyy'#'MM'#'dd'#'HH'#'mm'#'ss, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy'#'MM'#'dd'#'HH'#'mm'#'ss), #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2014-01-01 14:00:00+10:00, actual: 2013-12-01 14:00:00+10:00, pattern: null, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd HH:mm:ssZZZZZ), #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2014-01-01 14:00:00+10:00, actual: I'm a timestamp!, pattern: null, mustBeEmpty: false, matcher: TimestampMatcher(format=yyyy-MM-dd HH:mm:ssZZZZZ), #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2014-01-01 14:00:00+10:00, actual: null, pattern: null, mustBeEmpty: false, matcher: TimestampMatcher(format=yyyy-MM-dd HH:mm:ssZZZZZ), #3]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2014-01-01T10:00+10:00[Australia/Melbourne], actual: 2020-01-01T10:00+01:00[Europe/Warsaw], pattern: yyyy-MM-dd'T'HH:mmXXX'['zzz']', mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mmXXX'['zzz']'), #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+0200, actual: 2019-11-25T11:45:00Z, pattern: yyyy-MM-dd'T'HH:mm:ss'Z', mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ss'Z'), #12]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+0200, actual: 2019-11-25T11:45:00Z, pattern: yyyy-MM-dd'T'HH:mm:ssZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ssZ), #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+0200, actual: 2019-11-25T11:45Z, pattern: yyyy-MM-dd'T'HH:mmZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mmZ), #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+0200, actual: 2019-11-25T11Z, pattern: yyyy-MM-dd'T'HHZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HHZ), #11]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+02:00, actual: 2019-11-25T11:45:00Z, pattern: yyyy-MM-dd'T'HH:mm:ssX, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ssX), #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+02:00, actual: 2019-11-25T11:45:00Z, pattern: yyyy-MM-dd'T'HH:mm:ssZZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ssZZ), #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+02:00, actual: 2019-11-25T11:45Z, pattern: yyyy-MM-dd'T'HH:mmZZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mmZZ), #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00+02:00, actual: 2019-11-25T11Z, pattern: yyyy-MM-dd'T'HHZZ, mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HHZZ), #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00:000+0200, actual: 2019-11-25T11:19:00.000Z, pattern: yyyy-MM-dd'T'HH:mm:ss.SSS'Z', mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ss.SSS'Z'), #14]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00:000000+0200, actual: 2019-11-25T11:19:00.000000Z, pattern: yyyy-MM-dd'T'HH:mm:ss.SSS'Z', mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ss.SSS'Z'), #15]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ timestamp matcher [expected: 2019-11-25T13:45:00:000000+0200, actual: 2019-11-25T11:19:00.000000Z, pattern: yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z', mustBeEmpty: true, matcher: TimestampMatcher(format=yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'), #13]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 100, actual: 200, mustBeEmpty: true, #22]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 100, actual: 200.3, mustBeEmpty: true, #2]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 2.3, actual: 2.3, mustBeEmpty: true, #23]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 2.3, actual: 2.300, mustBeEmpty: true, #24]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 200, actual: 200, mustBeEmpty: false, #5]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: 200, actual: null, mustBeEmpty: false, #6]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a/>
, mustBeEmpty: true, #14]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: <?xml version="1.0" encoding="UTF-8"?><a/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b/>
, mustBeEmpty: false, #15]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><b:e xmlns:b="a"/>
, mustBeEmpty: true, #17]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><a:e xmlns:a="a"/>
, mustBeEmpty: true, #16]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: <?xml version="1.0" encoding="UTF-8"?><e xmlns="a"/>
, actual: <?xml version="1.0" encoding="UTF-8"?><e xmlns="b"/>
, mustBeEmpty: false, #18]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: Harry, actual: , mustBeEmpty: true, #1]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: Harry, actual: Some other string, mustBeEmpty: true, #0]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: [100, 200, 300], actual: [200.3], mustBeEmpty: true, #7]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: [100, 200, 300], actual: [], mustBeEmpty: true, #8]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: [a:100], actual: [:], mustBeEmpty: true, #10]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: [a:100], actual: [a:200.3, b:200, c:300], mustBeEmpty: true, #9]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: hello, actual: hello, mustBeEmpty: true, #19]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: hello, actual: hello, mustBeEmpty: true, #20]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: hello, actual: hello, mustBeEmpty: true, #21]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: null, actual: null, mustBeEmpty: true, #11]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: null, actual: null, mustBeEmpty: true, #12]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: null, actual: null, mustBeEmpty: true, #13]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: null, actual: null, mustBeEmpty: true, #4]
au.com.dius.pact.core.matchers.MatcherExecutorSpec ‑ type matcher matches on types [expected: true, actual: false, mustBeEmpty: true, #3]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/hal+json, matcherClass: au.com.dius.pact.core.matchers.JsonContentMatcher, #2]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/json-rpc, matcherClass: au.com.dius.pact.core.matchers.JsonContentMatcher, #5]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/jsonrequest, matcherClass: au.com.dius.pact.core.matchers.JsonContentMatcher, #6]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/stuff+xml, matcherClass: au.com.dius.pact.core.matchers.XmlContentMatcher, #4]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/thrift+json, matcherClass: au.com.dius.pact.core.matchers.JsonContentMatcher, #3]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/vnd.schemaregistry.v1+json, matcherClass: au.com.dius.pact.core.matchers.KafkaJsonSchemaContentMatcher, #0]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/x-other, matcherClass: au.com.dius.pact.core.matchers.PlainTextContentMatcher, #8]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/x-thrift, matcherClass: au.com.dius.pact.core.matchers.JsonContentMatcher, #7]
au.com.dius.pact.core.matchers.MatchingConfigSpec ‑ maps JSON content types to JSON body matcher [contentType: application/xml, matcherClass: au.com.dius.pact.core.matchers.XmlContentMatcher, #1]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ array contains matcher with simple values
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ array contains matcher with two expected values
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ calculatePathWeight - throws an exception if path is invalid
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ ignore-orderMatcherDefined - should be false when ignore-order matcher not defined on ancestor [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_8proc_closure8@7af443a3 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ ignore-orderMatcherDefined - should be false when ignore-order matcher not defined on path [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_7proc_closure7@5b000fe6 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ ignore-orderMatcherDefined - should be true when ignore-order matcher defined on ancestor [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_6proc_closure6@2a02e34b delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ ignore-orderMatcherDefined - should be true when ignore-order matcher defined on path [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_5proc_closure5@3281dfc2 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ matchers defined - should be false when the path does not have a matcher entry
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ matchers defined - should be false when there are no matchers
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ matchers defined - should be true when a parent of the path has a matcher entry [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_3proc_closure2@20c812c8 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ matchers defined - should be true when the path does have a matcher entry [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_2proc_closure1@32f32623 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ matchers defined - uses any provided path comparator [matchingRules: <au.com.dius.pact.core.matchers.MatchingContextSpec$__spock_feature_0_4proc_closure4@7061622 delegate=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 owner=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 thisObject=au.com.dius.pact.core.matchers.MatchingContextSpec@6b9fdbc6 resolveStrategy=0 directive=0 parameterTypes=[class java.lang.Object] maximumNumberOfParameters=1 bcw=null>, #0]
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ path matching - match array indices
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ path matching - match field name
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ path matching - match root node
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ path matching - match with wildcard
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ path matching - throws an exception if path is invalid
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ resolveMatchers returns all matchers for the general case
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ resolveMatchers returns matchers filtered by path for header
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ resolveMatchers returns matchers filtered by path for metadata
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ resolveMatchers returns matchers filtered by path for query
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ resolveMatchers returns matchers filtered by path length for body category
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ should default to a matching defined at a parent level
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ type matcher - match on type - list elements should inherit the matcher from the parent
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ type matcher - match on type - map elements should inherit the matchers from the parent
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ values matcher must not cascade
au.com.dius.pact.core.matchers.MatchingContextSpec ‑ with matching rules with the same weighting, select the one of the same path length
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - compares the body with any defined matcher
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - compares the bytes of the body [expected: 	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(4 bytes starting with 01020304...), actual: 	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(4 bytes starting with 01020304...), #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - compares the bytes of the body with text [expected: 	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(hello), actual: 	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(hello), #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - eachKeyMappedToAnArrayLike does not work on "nested" property
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - ignores well known body matchers if there is a content type matcher
au.com.dius.pact.core.matchers.MatchingSpec ‑ Body Matching - only use a matcher that can handle the body type
au.com.dius.pact.core.matchers.MatchingSpec ‑ Header Matching - complain about incorrect headers [mismatch: HeaderMismatch(headerKey=A, expected=B, actual=C, mismatch=Expected header 'A' to have value 'B' but was 'C'), #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Header Matching - complain about missing headers [mismatch: HeaderMismatch(headerKey=C, expected=D, actual=, mismatch=Expected a header 'C' but was missing), #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Header Matching - ignore additional headers
au.com.dius.pact.core.matchers.MatchingSpec ‑ Header Matching - match empty
au.com.dius.pact.core.matchers.MatchingSpec ‑ Header Matching - match same headers
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - complain about incorrect keys [mismatch: [MetadataMismatch(key=A, expected=B, actual=C, mismatch=Expected 'C' (String) to be equal to 'B' (String))], #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - complain about missing keys [mismatch: [MetadataMismatch(key=C, expected=D, actual=null, mismatch=Expected metadata 'C' but was missing)], #0]
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - ignore additional keys
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - ignores missing content type
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - match empty
au.com.dius.pact.core.matchers.MatchingSpec ‑ Metadata Matching - match same metadata
au.com.dius.pact.core.matchers.MatchingSpec ‑ each value matcher applying a regex to a list of strings
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with a non array default to a equality matcher [expected: Fred, actual: 100, match: false, #1]
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with a non array default to a equality matcher [expected: Fred, actual: Fred, match: true, #0]
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is correct size
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is correct, mixed
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is larger
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is larger, mixed
au.com.dius.pact.core.matchers.MaxEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is smaller
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ when cascaded, do not apply the limits
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ with a non array default to a type matcher [expected: Fred, actual: 100, beEmpty: false, #1]
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ with a non array default to a type matcher [expected: Fred, actual: George, beEmpty: true, #0]
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ with an array match if the array is smaller
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ with an array match if the array is the correct size
au.com.dius.pact.core.matchers.MaximumMatcherSpec ‑ with an array not match if the array is larger
au.com.dius.pact.core.matchers.MetadataMatcherSpec ‑ be false when metadatas are not equal
au.com.dius.pact.core.matchers.MetadataMatcherSpec ‑ be true when metadatas are equal
au.com.dius.pact.core.matchers.MetadataMatcherSpec ‑ combines mismatches if there are multiple
au.com.dius.pact.core.matchers.MetadataMatcherSpec ‑ delegate to a matcher when one is defined
au.com.dius.pact.core.matchers.MetadataMatcherSpec ‑ supports collections
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with a non array default to a equality matcher [expected: Fred, actual: 100, match: false, #1]
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with a non array default to a equality matcher [expected: Fred, actual: Fred, match: true, #0]
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is correct size
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is correct, mixed
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is larger
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is larger, mixed
au.com.dius.pact.core.matchers.MinEqualsIgnoreOrderMatcherSpec ‑ with an array match if the actual is smaller
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ when cascaded, do not apply the limits
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ with a non array default to a type matcher [expected: Fred, actual: 100, beEmpty: false, #1]
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ with a non array default to a type matcher [expected: Fred, actual: George, beEmpty: true, #0]
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ with an array match if the array is larger
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ with an array match if the array is the correct size
au.com.dius.pact.core.matchers.MinimumMatcherSpec ‑ with an array not match if the array is smaller
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ Ignores missing content type header, which is optional [actualBody: PRESENT(89 bytes starting with 2d2d5858580a436f6e74656e742d4469...), expectedBody: PRESENT(114 bytes starting with 2d2d5858580a436f6e74656e742d4469...), #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ return no mismatches - when comparing a missing body to anything [actualBody: PRESENT("Blah"), expectedBody: MISSING, #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ return no mismatches - when comparing empty bodies [actualBody: EMPTY, expectedBody: EMPTY, #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ returns a mismatch - when comparing anything to an empty body [actualBody: EMPTY, expectedBody: PRESENT("Blah"), #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ returns a mismatch - when the actual body is empty [actualBody: PRESENT(185 bytes starting with 2d2d4747776162377733613345734a53...), expectedBody: PRESENT(187 bytes starting with 2d2d4c6c31787a7a783076676667426c...), #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ returns a mismatch - when the headers do not match [actualBody: PRESENT(181 bytes starting with 2d2d456e6261463639596d4a6563565a...), expectedBody: PRESENT(168 bytes starting with 2d2d7175775641366c49363758783843...), #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ returns a mismatch - when the number of parts is different [actualBody: PRESENT(300 bytes starting with 2d2d31582d757242347455625a487a79...), expectedBody: PRESENT(170 bytes starting with 2d2d676849776a79356f68614e47464d...), #0]
au.com.dius.pact.core.matchers.MultipartMessageContentMatcherSpec ‑ returns a mismatch - when the parts have different content [actualBody: PRESENT(198 bytes starting with 2d2d6b4c4175657a68653350536d7168...), expectedBody: PRESENT(194 bytes starting with 2d2d423376546e527332466d31366774...), #0]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ Compares using equality if there is no matcher defined [expected: expected, actual: actual, result: false, #0]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ Compares using equality if there is no matcher defined [expected: expected, actual: expected, result: true, #1]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ Uses the matcher if there is a matcher defined [expected: expected, actual: 12324, rules: [body:[$:[matchers:[[match:integer]]]]], result: false, #2]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ Uses the matcher if there is a matcher defined [expected: expected, actual: actual, rules: [body:[$:[matchers:[[match:regex, regex:\d+]]]]], result: false, #0]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ Uses the matcher if there is a matcher defined [expected: expected, actual: actual, rules: [body:[$:[matchers:[[match:regex, regex:\w+]]]]], result: true, #1]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ supports matching multiple line text [expected: expected, actual: 12324
12
122, rules: [body:[$:[matchers:[[match:regex, regex:(^\d+$
?)+]]]]], #2]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ supports matching multiple line text [expected: expected, actual: Hello
World, rules: [body:[$:[matchers:[[match:regex, regex:(^\w+$
?)*]]]]], #0]
au.com.dius.pact.core.matchers.PlainTextContentMatcherSpec ‑ supports matching multiple line text [expected: expected, actual: Hello
World, rules: [body:[$:[matchers:[[match:regex, regex:^.+$]]]]], #1]
au.com.dius.pact.core.matchers.QueryMatcherSpec ‑ applies matching rules to multiple parameter values
au.com.dius.pact.core.matchers.QueryMatcherSpec ‑ applies matching rules to the parameter values
au.com.dius.pact.core.matchers.QueryMatcherSpec ‑ checks the number of parameters
au.com.dius.pact.core.matchers.QueryMatcherSpec ‑ uses equality by default
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=BodyTypeMismatch(expected=, actual=), bodyResults=[BodyItemMatchResult(key=a, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])]), score: 2, #3]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=BodyTypeMismatch(expected=, actual=), bodyResults=[BodyItemMatchResult(key=a, result=[]), BodyItemMatchResult(key=b, result=[])]), score: 2, #4]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=BodyTypeMismatch(expected=, actual=), bodyResults=[BodyItemMatchResult(key=a, result=[])]), score: 2, #2]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=BodyTypeMismatch(expected=, actual=), bodyResults=[]), score: 2, #1]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[BodyItemMatchResult(key=a, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)]), BodyItemMatchResult(key=b, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])]), score: 1, #7]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[BodyItemMatchResult(key=a, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])]), score: 2, #5]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[BodyItemMatchResult(key=a, result=[]), BodyItemMatchResult(key=b, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])]), score: 3, #8]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[BodyItemMatchResult(key=a, result=[]), BodyItemMatchResult(key=b, result=[])]), score: 5, #9]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[BodyItemMatchResult(key=a, result=[])]), score: 4, #6]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ body matching scoring [body: BodyMatchResult(typeMismatch=null, bodyResults=[]), score: 3, #0]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [HeaderMatchResult(key=a, result=[HeaderMismatch(headerKey=a, expected=1, actual=2, mismatch=)]), HeaderMatchResult(key=b, result=[HeaderMismatch(headerKey=b, expected=1, actual=2, mismatch=)])], score: 1, #3]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [HeaderMatchResult(key=a, result=[HeaderMismatch(headerKey=a, expected=1, actual=2, mismatch=)]), HeaderMatchResult(key=b, result=[])], score: 3, #4]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [HeaderMatchResult(key=a, result=[HeaderMismatch(headerKey=a, expected=1, actual=2, mismatch=)])], score: 2, #1]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [HeaderMatchResult(key=a, result=[]), HeaderMatchResult(key=b, result=[])], score: 5, #5]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [HeaderMatchResult(key=a, result=[])], score: 4, #2]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ header matching scoring [header: [], score: 3, #0]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [QueryMatchResult(key=a, result=[QueryMismatch(queryParameter=a, expected=1, actual=2, mismatch=, path=)]), QueryMatchResult(key=b, result=[QueryMismatch(queryParameter=b, expected=1, actual=2, mismatch=, path=)])], score: 1, #3]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [QueryMatchResult(key=a, result=[QueryMismatch(queryParameter=a, expected=1, actual=2, mismatch=, path=)]), QueryMatchResult(key=b, result=[])], score: 3, #4]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [QueryMatchResult(key=a, result=[QueryMismatch(queryParameter=a, expected=1, actual=2, mismatch=, path=)])], score: 2, #1]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [QueryMatchResult(key=a, result=[]), QueryMatchResult(key=b, result=[])], score: 5, #5]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [QueryMatchResult(key=a, result=[])], score: 4, #2]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ query matching scoring [query: [], score: 3, #0]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: PathMismatch(expected=/, actual=/1, mismatch=null), query: [], cookie: null, headers: [], body: [], score: -1, #8]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [QueryMatchResult(key=a, result=[QueryMismatch(queryParameter=a, expected=1, actual=2, mismatch=, path=)])], cookie: null, headers: [], body: [], score: 0, #9]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [], cookie: CookieMismatch(expected=[], actual=[]), headers: [], body: [], score: -1, #10]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [], cookie: null, headers: [HeaderMatchResult(key=a, result=[HeaderMismatch(headerKey=a, expected=1, actual=2, mismatch=)])], body: [], score: 0, #11]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [], cookie: null, headers: [], body: [BodyItemMatchResult(key=$.a, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])], score: 0, #12]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [], cookie: null, headers: [], body: [], score: 1, #1]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: MethodMismatch(expected=GET, actual=POST), path: null, query: [], cookie: null, headers: [], body: [], score: 1, #7]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: PathMismatch(expected=/, actual=/1, mismatch=null), query: [], cookie: null, headers: [], body: [], score: 1, #2]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: null, query: [QueryMatchResult(key=a, result=[QueryMismatch(queryParameter=a, expected=1, actual=2, mismatch=, path=)])], cookie: null, headers: [], body: [], score: 2, #3]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: null, query: [], cookie: CookieMismatch(expected=[], actual=[]), headers: [], body: [], score: 1, #4]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: null, query: [], cookie: null, headers: [HeaderMatchResult(key=a, result=[HeaderMismatch(headerKey=a, expected=1, actual=2, mismatch=)])], body: [], score: 2, #5]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: null, query: [], cookie: null, headers: [], body: [BodyItemMatchResult(key=$.a, result=[BodyMismatch(expected=a, actual=b, mismatch=, path=/, diff=null)])], score: 2, #6]
au.com.dius.pact.core.matchers.RequestMatchResultSpec ‑ test for match result scoring [method: null, path: null, query: [], cookie: null, headers: [], body: [], score: 3, #0]
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ path matching should allow matching with a defined matcher
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ path matching should match when the paths are equal
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ path matching should not match when the paths are different
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ path matching should not match with the defined matcher
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should allow additional headers
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should allow query string in different order
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should disallow additional keys
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should fail if query string has the same parameter repeated in different order
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should fail to match when headers are present but contain incorrect value
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should fail to match when missing headers
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should match the valid request
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should require precise matching
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request matching should trim protocol, server name and port
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should match if actual cookie contains more data than expected one
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should match if actual cookie exactly matches the expected
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should match when cookie field is different from cases
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should match when there are spaces between cookie items
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should mismatch if actual cookie contains less data than expected cookie
au.com.dius.pact.core.matchers.RequestMatchingSpec ‑ request with cookie should mismatch if actual cookie has no intersection with expected request
au.com.dius.pact.core.matchers.ResponseMatchingSpec ‑ response matching - match statuses
au.com.dius.pact.core.matchers.ResponseMatchingSpec ‑ response matching - mismatch statuses
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match decimal should accept decimal values
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match decimal should fail for non-decimal values
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match decimal should handle null values
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match integers should accept integer values
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match integers should fail for non-integer values
au.com.dius.pact.core.matchers.TypeMatcherSpec ‑ match integers should not match null values
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when a tag has an invalid value
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when a tag has the same number of attributes but different keys
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when a tag is missing an attribute
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when allowUnexpectedKeys is true - and no namespace is expected
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when attribute uses different namespace
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing a list to one with with different size
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing a list to one with with the same size but different children
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing a tags attributes to one with less entries
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing a tags attributes to one with more entries
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing an empty list to a non-empty one
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when comparing anything to an empty body
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when different namespaces are used
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when expected namespace is not used
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when the content of an element does not match
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns a mismatch - when the root elements do not match
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - returns no mismatch - when comparing a list to one where the items are in the wrong order
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when allowUnexpectedKeys is true - and comparing a list to a super-set
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when allowUnexpectedKeys is true - and comparing a tags attributes to one with more entries
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when allowUnexpectedKeys is true - and comparing an empty list to a non-empty one
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when allowUnexpectedKeys is true - and namespace-aware matching disabled - and no namespace is expected
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when attribute uses different prefix
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when bodies differ only in whitespace
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when comparing a missing body to anything
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when comparing empty bodies
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - when comparing missing bodies
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with CDATA elements
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with CDATA elements matching with regex
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with a matcher defined - delegate to the matcher
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations - and have child elements [actual: <a:foo xmlns:a="urn:ns"><a2:item xmlns:a2="urn:ns"/></a:foo>, expected: <b:foo xmlns:b="urn:ns"><b:item/></b:foo>, #4]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations - and have child elements [actual: <a:foo xmlns:a="urn:ns"><a:item/></a:foo>, expected: <b:foo xmlns:b="urn:ns"><b:item/></b:foo>, #3]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations - and have child elements [actual: <a:foo xmlns:a="urn:ns"><a:item/></a:foo>, expected: <foo xmlns="urn:ns"><item/></foo>, #2]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations - and have child elements [actual: <foo xmlns="urn:ns"><item/></foo>, expected: <b:foo xmlns:b="urn:ns"><b:item/></b:foo>, #1]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations - and have child elements [actual: <foo xmlns="urn:ns"><item/></foo>, expected: <foo xmlns="urn:ns"><item/></foo>, #0]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations [actual: <a:blah xmlns:a="urn:ns"/>, expected: <b:blah xmlns:b="urn:ns"/>, #3]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations [actual: <a:blah xmlns:a="urn:ns"/>, expected: <blah xmlns="urn:ns"/>, #2]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations [actual: <blah xmlns="urn:ns"/>, expected: <b:blah xmlns:b="urn:ns"/>, #1]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with different namespace declarations [actual: <blah xmlns="urn:ns"/>, expected: <blah xmlns="urn:ns"/>, #0]
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with equal bodies
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with namespaces and a matcher defined - delegate to matcher for attribute
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with namespaces and a matcher defined - delegate to the matcher
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ matching XML bodies - with unexpected elements
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ type matcher when an element has different types of children
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ when an element has different types of children but we allow unexpected keys
au.com.dius.pact.core.matchers.XmlContentMatcherSpec ‑ when an element has different types of children but we do not allow unexpected keys
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1, 2, 3], size: 0, result: [], #3]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1, 2, 3], size: 2, result: [1, 2], #4]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1, 2, 3], size: 3, result: [1, 2, 3], #5]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1, 2, 3], size: 6, result: [1, 2, 3, 1, 1, 1], #8]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1], size: 0, result: [], #2]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1], size: 1, result: [1], #1]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [1], size: 3, result: [1, 1, 1], #7]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [], size: 0, result: [], #0]
au.com.dius.pact.core.matchers.util.CollectionUtilsSpec ‑ padTo test [list: [], size: 3, result: [1, 1, 1], #6]
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of 0 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of 1 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of 2 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of 32 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of 33 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ produces correct sequence of indices for collection
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [0, 1, 2] from collection of 3 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [0, 2] from collection of 3 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [0] from collection of 3 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [1] from collection of 3 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [2] from collection of 3 indices
au.com.dius.pact.core.matchers.util.IndicesCombinationSpec ‑ removes [5, 33] from collection of 36 indices
au.com.dius.pact.core.matchers.util.LargestKeyValueSpec ‑ gets the largest value
au.com.dius.pact.core.model.BasePactSpec ‑ metadata should use the metadata from the pact file as a base
au.com.dius.pact.core.model.BrokerUrlSourceSpec ‑ description includes the tag if one is set [source: BrokerUrlSource(url=URL, pactBrokerUrl=Broker URL, attributes={}, options={}, tag=TAG, result=null), description: Pact Broker URL (Tag TAG), #1]
au.com.dius.pact.core.model.BrokerUrlSourceSpec ‑ description includes the tag if one is set [source: BrokerUrlSource(url=URL, pactBrokerUrl=Broker URL, attributes={}, options={}, tag=null, result=null), description: Pact Broker URL, #0]
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" charset -> UTF-8
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" is json -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" is xml -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "" supertype -> null
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/HAL+JSON" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/HAL+JSON" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/HAL+JSON" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/HAL+JSON" supertype -> application/json
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/STUFF+XML" is xml -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/atom+xml" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/atom+xml" supertype -> application/xml
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/graphql" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/graphql" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/hal+json" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/hal+json" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/hal+json" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/hal+json" supertype -> application/json
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/json" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/json" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/json" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/json" supertype -> application/javascript
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/octet-stream" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/octet-stream" supertype -> null
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf" is json -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf" is xml -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/pdf;a=b" charset -> UTF-8
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/stuff+xml" is xml -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/vnd.schemaregistry.v1+json" is json -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/vnd.schemaregistry.v1+json" is kafka schema registry -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/vnd.siren+json" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/vnd.siren+json" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/vnd.siren+json" supertype -> application/json
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-bin" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-ml" is xml -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-other" is json -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-other" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-thrift" is json -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-thrift" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-thrift" is xml -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-www-form-urlencoded" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/x-www-form-urlencoded" supertype -> text/plain
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/xml ; charset=UTF-16" charset -> UTF-16
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/xml" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/xml" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/xml" is xml -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/xml" supertype -> text/plain
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/zip" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "application/zip" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "audio/aac" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "audio/aac" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "image/jpeg" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "image/jpeg" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "multipart/form-data" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "multipart/form-data" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/csv" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/csv" supertype -> text/plain
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" charset -> UTF-8
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" is binary -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" is json -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" is kafka schema registry -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" is xml -> false
au.com.dius.pact.core.model.ContentTypeSpec ‑ "text/plain" supertype -> application/octet-stream
au.com.dius.pact.core.model.ContentTypeSpec ‑ "video/H264" is binary -> true
au.com.dius.pact.core.model.ContentTypeSpec ‑ "video/H264" supertype -> application/octet-stream
au.com.dius.pact.core.model.DirectorySourceSpec ‑ description includes the directory Pacts are contained in
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ feature toggle test [name: , featureSet: false, #0]
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ feature toggle test [name: pact, featureSet: false, #1]
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ feature toggle test [name: pact.feature.matchers.useMatchValuesMatcher, featureSet: false, #2]
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ feature toggle test [name: pact.test, featureSet: true, #3]
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ feature toggle test [name: pact.test.2, featureSet: false, #4]
au.com.dius.pact.core.model.FeatureTogglesSpec ‑ updated toogles only returns the toogles that are different
au.com.dius.pact.core.model.GeneratedRequestSpec ‑ applies body generators for body values to the copy of the request
au.com.dius.pact.core.model.GeneratedRequestSpec ‑ applies header generator for headers to the copy of the request
au.com.dius.pact.core.model.GeneratedRequestSpec ‑ applies path generator for path to the copy of the request
au.com.dius.pact.core.model.GeneratedRequestSpec ‑ applies query generator for query parameters to the copy of the request
au.com.dius.pact.core.model.GeneratedResponseSpec ‑ applies body generators for body values to the copy of the response
au.com.dius.pact.core.model.GeneratedResponseSpec ‑ applies header generator for headers to the copy of the response
au.com.dius.pact.core.model.GeneratedResponseSpec ‑ applies status generator for status to the copy of the response
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - date header
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - header with multiple values
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - header with multiple values with parameters
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - header with parameter
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - header with quoted values
au.com.dius.pact.core.model.HeaderParserSpec ‑ loading string headers from JSON - simple header
au.com.dius.pact.core.model.HeaderParserSpec ‑ support quoted values as per RFC 1341
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact charset [request: 	method: Get
	path: 
	query: {}
	headers: {Content-Type=[application/json; charset=UTF-16]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, charset: UTF-16, #2]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact charset [request: 	method: Get
	path: 
	query: {}
	headers: {Content-Type=[text/html]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, charset: UTF-8, #1]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact charset [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, charset: null, #0]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {CONTENT-TYPE=[application/json]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, contentType: application/json, #4]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {Content-Type=[application/json; charset=UTF-8]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, contentType: application/json, #2]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {Content-Type=[text/html]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, contentType: text/html, #1]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {content-type=[application/json]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, contentType: application/json, #3]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, contentType: null, #0]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT("string"), contentType: application/json, #9]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(<?xml version="1.0" encoding="UTF-8"?>
<json>false</json>), contentType: application/xml, #10]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(<html><body>this is also not json</body></html>), contentType: text/html, #13]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(<json>false</json>), contentType: application/xml, #11]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT([1,2,3]), contentType: application/json, #8]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT([]), contentType: application/json, #7]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT(this is not json), contentType: text/plain, #12]

au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT({"json": true}), contentType: application/json, #5]
au.com.dius.pact.core.model.HttpPartSpec ‑ Pact contentType [request: 	method: Get
	path: 
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT({}), contentType: application/json, #6]
au.com.dius.pact.core.model.HttpPartSpec ‑ handles base64 encoded bodies
au.com.dius.pact.core.model.HttpPartSpec ‑ returns the raw body if it can not be decoded
au.com.dius.pact.core.model.HttpPartSpec ‑ takes into account content type overrides
au.com.dius.pact.core.model.HttpRequestSpec ‑ allows configuring the interaction from properties
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports empty bodies
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports setting up the headers [headerValue: [a:[b]], headers: [a:[b]], #0]
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports setting up the headers [headerValue: [a:b], headers: [a:[b]], #1]
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports setting up the query parameters [queryValue: [a:[b]], query: [a:[b]], #0]
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports setting up the query parameters [queryValue: [a:b], query: [a:[b]], #1]
au.com.dius.pact.core.model.HttpRequestSpec ‑ supports setting up the query parameters [queryValue: a=b, query: [a:[b]], #2]
au.com.dius.pact.core.model.HttpResponseSpec ‑ allows configuring the interaction from properties
au.com.dius.pact.core.model.HttpResponseSpec ‑ supports empty bodies
au.com.dius.pact.core.model.HttpResponseSpec ‑ supports setting up the headers [headerValue: [a:[b]], headers: [a:[b]], #0]
au.com.dius.pact.core.model.HttpResponseSpec ‑ supports setting up the headers [headerValue: [a:b], headers: [a:[b]], #1]
au.com.dius.pact.core.model.HttpResponseSpec ‑ supports setting up the status [statusValue: 203, status: 203, #1]
au.com.dius.pact.core.model.HttpResponseSpec ‑ supports setting up the status [statusValue: 204, status: 204, #0]
au.com.dius.pact.core.model.InteractionSpec ‑ display state should show a description of the state [state: ProviderState(name=, params={}), description: None, #1]
au.com.dius.pact.core.model.InteractionSpec ‑ display state should show a description of the state [state: ProviderState(name=null, params={}), description: None, #2]
au.com.dius.pact.core.model.InteractionSpec ‑ display state should show a description of the state [state: ProviderState(name=some state, params={}), description: some state, #0]
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do conflict if their requests are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do conflict if their responses are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if their descriptions are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if their provider states are different
au.com.dius.pact.core.model.InteractionSpec ‑ interactions do not conflict if they are equal
au.com.dius.pact.core.model.JsonUtilsSpec ‑ fetchPath [path: $, json: null, value: null, #0]
au.com.dius.pact.core.model.JsonUtilsSpec ‑ fetchPath [path: $, json: {}, value: {}, #1]
au.com.dius.pact.core.model.JsonUtilsSpec ‑ fetchPath [path: $.a, json: {"a": 100, "b": 200}, value: 100, #2]
au.com.dius.pact.core.model.JsonUtilsSpec ‑ fetchPath [path: $.a[1], json: {"a": [100, 101, 102], "b": 200}, value: 101, #3]
au.com.dius.pact.core.model.JsonUtilsSpec ‑ throws an exception if given an invalid path
au.com.dius.pact.core.model.OptionalBodySpec ‑ charset test [body: PRESENT({}), charset: UTF-8, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ charset test [body: PRESENT({}), charset: UTF-8, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ charset test [body: PRESENT({}), charset: UTF-8, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ charset test [body: PRESENT(筽), charset: UTF-16, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: EMPTY, contentType: null, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: MISSING, contentType: null, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: PRESENT(28058 bytes starting with ffd8ffe000104a46494600010101012c...), contentType: image/jpeg, #5]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: PRESENT(<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoders are assigned the type
             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="org.reflections" level="ERROR"/>

    <!-- Strictly speaking, the level attribute is not necessary since -->
    <!-- the level of the root level is set to DEBUG by default.       -->
    <root level="DEBUG">
        <appender-ref ref="STDOUT" />
    </root>

</configuration>
), contentType: application/xml, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: PRESENT({
  "provider": {
    "name": "ApiProvider"
  },
  "consumer": {
    "name": "ApiConsumer"
  },
  "interactions": [
    {
      "description": "GET request to retrieve default values",
      "request": {
        "method": "GET",
        "path": "/api/test/8",
        "matchingRules": {
          "path": {
            "matchers": [
              {
                "match": "regex",
                "regex": "/api/test/\\d{1,8}"
              }
            ],
            "combine": "OR"
          }
        }
      },
      "response": {
        "status": 200,
        "headers": {
          "Content-Type": "application/json"
        },
        "body": [
          {
            "size": 1445211,
            "name": "testId254",
            "id": 32432
          }
        ],
        "matchingRules": {
          "body": {
            "$": {
              "matchers": [
                {
                  "match": "type",
                  "min": 1
                }
              ],
              "combine": "AND"
            },
            "$[*].id": {
              "matchers": [
                {
                  "match": "number"
                }
              ],
              "combine": "AND"
            },
            "$[*].name": {
              "matchers": [
                {
                  "match": "type"
                }
              ],
              "combine": "AND"
            },
            "$[*].size": {
              "matchers": [
                {
                  "match": "number"
                }
              ],
              "combine": "AND"
            }
          }
        }
      },
      "providerStates": [
        {
          "name": "This is a test"
        }
      ]
    }
  ],
  "metadata": {
    "pactSpecification": {
      "version": "3.0.0"
    },
    "pact-jvm": {
      "version": "4.0.10"
    }
  }
}), contentType: application/json, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ detect content type test [body: PRESENT({}), contentType: application/json, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for empty [body: EMPTY, value: true, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for empty [body: EMPTY, value: true, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for empty [body: MISSING, value: false, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for empty [body: NULL, value: false, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for empty [body: PRESENT(a), value: false, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for missing [body: EMPTY, value: false, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for missing [body: MISSING, value: true, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for missing [body: NULL, value: false, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for missing [body: PRESENT(a), value: false, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: EMPTY, value: true, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: EMPTY, value: true, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: MISSING, value: true, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: NULL, value: true, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: NULL, value: true, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for not present [body: PRESENT(a), value: false, #5]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for nullBody [body: EMPTY, value: false, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for nullBody [body: MISSING, value: false, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for nullBody [body: NULL, value: true, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for nullBody [body: NULL, value: true, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for nullBody [body: PRESENT(a), value: false, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: EMPTY, value: false, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: EMPTY, value: false, #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: MISSING, value: false, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: NULL, value: false, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: NULL, value: false, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate state for present [body: PRESENT(a), value: true, #5]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: EMPTY, value: , #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: EMPTY, value: , #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: MISSING, value: default, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: NULL, value: default, #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: NULL, value: default, #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ returns the appropriate value for orElse [body: PRESENT(a), value: a, #5]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: EMPTY, v4Format: [content:], #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: MISSING, v4Format: [:], #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: PRESENT(10 bytes starting with 6b6a6c6b6a6c6b6a6b6c...), v4Format: [content:a2psa2psa2prbA==, contentType:application/other, encoded:base64, contentTypeHint:BINARY], #5]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: PRESENT(2 bytes starting with 7b7d...), v4Format: [content:{}, contentType:application/json, encoded:JSON], #6]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: PRESENT(4 bytes starting with ffd8ffe0...), v4Format: [content:/9j/4A==, contentType:image/jpeg, encoded:base64, contentTypeHint:DEFAULT], #4]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: PRESENT({}), v4Format: [content:{}, contentType:application/json, encoded:false], #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ to V4 format test [body: PRESENT({}), v4Format: [content:{}, contentType:application/json, encoded:false], #3]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap does not throw an exception when the body is not missing [body: EMPTY, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap does not throw an exception when the body is not missing [body: EMPTY, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap does not throw an exception when the body is not missing [body: PRESENT(a), #2]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap throws an exception when the body is missing [body: MISSING, #1]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap throws an exception when the body is missing [body: NULL, #0]
au.com.dius.pact.core.model.OptionalBodySpec ‑ unwrap throws an exception when the body is missing [body: NULL, #2]
au.com.dius.pact.core.model.OptionalBodyTest ‑ a body that contains a null is not empty
au.com.dius.pact.core.model.OptionalBodyTest ‑ a body that contains a null is not missing
au.com.dius.pact.core.model.OptionalBodyTest ‑ a body that contains a null is not present
au.com.dius.pact.core.model.OptionalBodyTest ‑ a body that contains a null is null
au.com.dius.pact.core.model.OptionalBodyTest ‑ a body that contains a null or else returns the else
au.com.dius.pact.core.model.OptionalBodyTest ‑ a missing body is missing
au.com.dius.pact.core.model.OptionalBodyTest ‑ a missing body is not empty
au.com.dius.pact.core.model.OptionalBodyTest ‑ a missing body is not null
au.com.dius.pact.core.model.OptionalBodyTest ‑ a missing body is not present
au.com.dius.pact.core.model.OptionalBodyTest ‑ a missing body or else returns the else
au.com.dius.pact.core.model.OptionalBodyTest ‑ a null body or else returns the else
au.com.dius.pact.core.model.OptionalBodyTest ‑ a null body variable is missing
au.com.dius.pact.core.model.OptionalBodyTest ‑ a null body variable is not empty
au.com.dius.pact.core.model.OptionalBodyTest ‑ a null body variable is not present
au.com.dius.pact.core.model.OptionalBodyTest ‑ a null body variable is null
au.com.dius.pact.core.model.OptionalBodyTest ‑ a present body is not empty
au.com.dius.pact.core.model.OptionalBodyTest ‑ a present body is not missing
au.com.dius.pact.core.model.OptionalBodyTest ‑ a present body is not null
au.com.dius.pact.core.model.OptionalBodyTest ‑ a present body is present
au.com.dius.pact.core.model.OptionalBodyTest ‑ a present body or else returns the body
au.com.dius.pact.core.model.OptionalBodyTest ‑ an empty body is empty
au.com.dius.pact.core.model.OptionalBodyTest ‑ an empty body is not missing
au.com.dius.pact.core.model.OptionalBodyTest ‑ an empty body is not null
au.com.dius.pact.core.model.OptionalBodyTest ‑ an empty body is not present
au.com.dius.pact.core.model.OptionalBodyTest ‑ an empty body or else returns empty
au.com.dius.pact.core.model.PactBrokerSourceSpec ‑ description includes the URL for the Broker [source: PactBrokerSource(host=localhost, port=80, scheme=http, pacts={}, url=null), description: Pact Broker http://localhost:80, #0]
au.com.dius.pact.core.model.PactBrokerSourceSpec ‑ description includes the URL for the Broker [source: PactBrokerSource(host=null, port=null, scheme=null, pacts={}, url=https://www.example.com:443), description: Pact Broker https://www.example.com:443, #2]
au.com.dius.pact.core.model.PactBrokerSourceSpec ‑ description includes the URL for the Broker [source: PactBrokerSource(host=www.example.com, port=443, scheme=https, pacts={}, url=null), description: Pact Broker https://www.example.com:443, #1]
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow different descriptions for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow different descriptions for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow different states for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow different states for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow identical interactions without duplication for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pact merge should allow identical interactions without duplication for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pacts with different consumers are compatible for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pacts with different consumers are compatible for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pacts with different providers are not compatible for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pacts with different providers are not compatible for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ Pacts with different types are not compatible
au.com.dius.pact.core.model.PactMergeSpec ‑ any compatible pact merges with an empty pact for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ any compatible pact merges with an empty pact for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ empty pact merges with any compatible pact for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ empty pact merges with any compatible pact for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ pact merge removes duplicates for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ pact merge removes duplicates for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ two compatible pacts merge if their interactions are compatible for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ two compatible pacts merge if their interactions are compatible for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactMergeSpec ‑ two empty compatible pacts merge ok for class au.com.dius.pact.core.model.RequestResponsePact
au.com.dius.pact.core.model.PactMergeSpec ‑ two empty compatible pacts merge ok for class au.com.dius.pact.core.model.messaging.MessagePact
au.com.dius.pact.core.model.PactReaderSpec ‑ Defaults to V3 pact provider states
au.com.dius.pact.core.model.PactReaderSpec ‑ Falls back to the to V2 pact provider state
au.com.dius.pact.core.model.PactReaderSpec ‑ correctly load pact file from S3
au.com.dius.pact.core.model.PactReaderSpec ‑ correctly loads V2 pact query strings
au.com.dius.pact.core.model.PactReaderSpec ‑ correctly loads V2 pact with string bodies
au.com.dius.pact.core.model.PactReaderSpec ‑ custom retry strategy is added to execution chain of client
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pact-specification":{"version":"1.2.3"}}}, version: 1.2.3, #7]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pactSpecification":"1.2.3"}}, version: 2.0.0, #3]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pactSpecification":{"version":"1.2.3"}}}, version: 1.2.3, #5]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pactSpecification":{"version":"3.0"}}}, version: 3.0, #6]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pactSpecification":{}}}, version: 2.0.0, #4]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{"pactSpecificationVersion":"1.2.3"}}, version: 1.2.3, #2]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {"metadata":{}}, version: 2.0.0, #1]
au.com.dius.pact.core.model.PactReaderSpec ‑ determining pact spec version [json: {}, version: 2.0.0, #0]
au.com.dius.pact.core.model.PactReaderSpec ‑ handle encoded values in the pact file
au.com.dius.pact.core.model.PactReaderSpec ‑ handle multipart form post bodies
au.com.dius.pact.core.model.PactReaderSpec ‑ handles invalid version metadata
au.com.dius.pact.core.model.PactReaderSpec ‑ if authentication is set, sets up the http client with auth
au.com.dius.pact.core.model.PactReaderSpec ‑ loading pact displays warning and does not load rules correctly
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a message pact with V3 version using V3 loader
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact from a json string
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact from an inputstream
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact where the source is a closure
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with V1 version using existing loader
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with V2 version and encoded paths for query parameters and headers
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with V2 version using existing loader
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with V3 version using V3 loader
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with no metadata as V2
au.com.dius.pact.core.model.PactReaderSpec ‑ loads a pact with old version format
au.com.dius.pact.core.model.PactReaderSpec ‑ reads from classpath inside jar
au.com.dius.pact.core.model.PactReaderSpec ‑ throws a meaningful exception when reading from non-existent classpath
au.com.dius.pact.core.model.PactReaderSpec ‑ throws an exception if it can not load the pact file
au.com.dius.pact.core.model.PactReaderSpec ‑ when loading a message pact from the broker, it preserves the interaction ids
au.com.dius.pact.core.model.PactReaderSpec ‑ when loading a pact with V2 version from the broker, it preserves the interaction ids
au.com.dius.pact.core.model.PactReaderSpec ‑ when loading a pact with V3 version from the broker, it preserves the interaction ids
au.com.dius.pact.core.model.PactReaderTransformSpec ‑ converts provider state to camel case
au.com.dius.pact.core.model.PactReaderTransformSpec ‑ converts request and response matching rules
au.com.dius.pact.core.model.PactReaderTransformSpec ‑ converts the http methods to upper case
au.com.dius.pact.core.model.PactReaderTransformSpec ‑ handles both a snake and camel case provider state
au.com.dius.pact.core.model.PactReaderTransformSpec ‑ only transforms legacy fields
au.com.dius.pact.core.model.PactSerialiserSpec ‑ Correctly handle non-ascii characters
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must convert http methods to upper case [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must convert methods to uppercase
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise V3 pact [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise message pact with generators [pact: MessagePact(provider=Provider(name=test_provider), consumer=Consumer(name=test_consumer), messages=[Message(description='Test Message', providerStates=[ProviderState(name=message exists, params={})], contents=PRESENT("Test Message"), matchingRules=MatchingRules(rules={}), generators=Generators(categories={BODY={a=UuidGenerator(format=null)}}), metadata={contentType=application/json})], metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise pact [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise pact matchers in old format [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise pact with generators [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must de-serialise pact with matchers [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=3.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with encoded query string [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=2.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with no bodies [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=2.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with no metadata [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=2.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with no specification version [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pact-jvm={version=}, pactSpecification={version=2.0.0}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with no version [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=2.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must deserialise pact with query in old format [pact: BasePact(consumer=Consumer(name=test_consumer), provider=Provider(name=test_provider), metadata={pactSpecification={version=2.0.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.InputStreamPactSource@2ce47652), #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must not convert fields called 'body' [pactBody: [body:[1, 2, 3], complete:[body:123456, certificateUri:http://..., issues:[idNotFound:[:]], nevdis:[body:null, colour:null, engine:null]]], #0]
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must serialise V3 pact
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must serialise message pact with generators
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must serialise pact
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must serialise pact with generators
au.com.dius.pact.core.model.PactSerialiserSpec ‑ PactSerialiser must serialise pact with matchers
au.com.dius.pact.core.model.PactSpec ‑ Pact should Locate Interactions
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: , expected: V3, #0]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: V1, expected: V1, #1]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: V1_1, expected: V1_1, #2]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: V2, expected: V2, #3]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: V3, expected: V3, #4]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version [version: V4, expected: V4, #5]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version when invalid
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ default version when not set
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 0, version: V3, #0]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 1, version: V1, #1]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 2, version: V2, #2]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 3, version: V3, #3]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 4, version: V4, #4]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ from int [intValue: 5, version: V3, #5]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: UNSPECIFIED, result: V3, #0]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: V1, result: V1, #6]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: V1_1, result: V1_1, #12]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: V2, result: V2, #18]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: V3, result: V3, #24]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: UNSPECIFIED, otherVersion: V4, result: V4, #30]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: UNSPECIFIED, result: V1, #1]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: V1, result: V1, #7]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: V1_1, result: V1, #13]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: V2, result: V1, #19]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: V3, result: V1, #25]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1, otherVersion: V4, result: V1, #31]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: UNSPECIFIED, result: V1_1, #2]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: V1, result: V1_1, #8]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: V1_1, result: V1_1, #14]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: V2, result: V1_1, #20]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: V3, result: V1_1, #26]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V1_1, otherVersion: V4, result: V1_1, #32]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: UNSPECIFIED, result: V2, #3]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: V1, result: V2, #9]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: V1_1, result: V2, #15]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: V2, result: V2, #21]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: V3, result: V2, #27]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V2, otherVersion: V4, result: V2, #33]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: UNSPECIFIED, result: V3, #4]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: V1, result: V3, #10]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: V1_1, result: V3, #16]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: V2, result: V3, #22]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: V3, result: V3, #28]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V3, otherVersion: V4, result: V3, #34]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: UNSPECIFIED, result: V4, #5]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: V1, result: V4, #11]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: V1_1, result: V4, #17]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: V2, result: V4, #23]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: V3, result: V4, #29]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ or [version: V4, otherVersion: V4, result: V4, #35]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: UNSPECIFIED, result: 3.0.0, #0]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: V1, result: 1.0.0, #1]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: V1_1, result: 1.1.0, #2]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: V2, result: 2.0.0, #3]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: V3, result: 3.0.0, #4]
au.com.dius.pact.core.model.PactSpecVersionSpec ‑ version string [version: V4, result: 4.0, #5]
au.com.dius.pact.core.model.PactWriterSpec ‑ encode the query parameters correctly with V2 pact files
au.com.dius.pact.core.model.PactWriterSpec ‑ handle non-ascii characters correctly
au.com.dius.pact.core.model.PactWriterSpec ‑ keep null attributes in the body
au.com.dius.pact.core.model.PactWriterSpec ‑ overwrite any existing pact file if the pact.writer.overwrite property is set
au.com.dius.pact.core.model.PactWriterSpec ‑ when merging pact files, the original file must be read using UTF-8
au.com.dius.pact.core.model.PactWriterSpec ‑ when writing a pact file to disk, merge the pact with any existing one
au.com.dius.pact.core.model.PactWriterSpec ‑ when writing message pact files, the metadata values should be stored as JSON
au.com.dius.pact.core.model.PactWriterSpec ‑ when writing message pacts, do not include optional items that are missing
au.com.dius.pact.core.model.PactWriterSpec ‑ when writing pacts, do not include optional items that are missing
au.com.dius.pact.core.model.PactWriterSpec ‑ when writing pacts, do not parse JSON string bodies
au.com.dius.pact.core.model.PactWriterSpec ‑ write synchronous message pact as V3 throws an exception
au.com.dius.pact.core.model.PactWriterSpec ‑ write synchronous message pact test
au.com.dius.pact.core.model.PactWriterSpec ‑ writing V4 pacts with comments
au.com.dius.pact.core.model.PactWriterSpec ‑ writing V4 pacts with pending interactions
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: $a.b, root: a.b, result: a.b['$a.b'], #8]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: , root: , result: , #0]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: , root: a, result: a, #2]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a b, root: a.b, result: a.b['a b'], #7]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a$, root: a.b, result: a.b['a$'], #6]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a, root: , result: a, #1]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a, root: a, result: a.a, #3]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a, root: a., result: a.a, #4]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Constructing valid path expressions [segment: a, root: a.b, result: a.b.a, #5]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Empty String
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Invalid Identifiers in "$.a.b.c.}"
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Invalid Identifiers in "$.abc!"
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Missing Path
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Missing Path Name in "$."
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Missing Path Name in "$.a.b.c."
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Missing Root
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp Handles Root
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Bracket Notation - $.a['val@1.'].c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Bracket Notation - $.a[*].c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Bracket Notation - $.a[1].c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Bracket Notation - $['val1']
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Index Notation - $[-1]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Index Notation - $[12abc]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Index Notation - $[]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Index Notation - $[dhghh]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $[
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['']
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['Unterminated string
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['test'
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['test'.b.c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Invalid Bracket Notation - $['test']b.c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Punctuation in Identifiers - $.container_records.example-ABC
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Punctuation in Identifiers - $.container_records.example:ABC
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Punctuation in Identifiers - $.container_records.example_ABC
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Punctuation in Identifiers - $.container_records['example/ABC']
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Punctuation in Identifiers - $.container_records['example:ABC']
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Simple Identifiers - $._b
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Simple Identifiers - $.a
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Simple Identifiers - $.a-b
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Simple Identifiers - $.a.b.c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Simple Identifiers - $.a_b
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Star Instead Of Identifiers - $.*
au.com.dius.pact.core.model.PathExpressionsSpec ‑ Parse Path Exp With Star Instead Of Identifiers - $.a.*.c
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$, *], result: $.*, #6]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$, ['a.b']], result: $['a.b'], #4]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$, [*]], result: $[*], #8]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$, a, [*]], result: $.a[*], #10]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$, a], result: $.a, #2]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [$], result: $, #1]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [*], result: *, #7]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [['a.b']], result: ['a.b'], #5]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [[*]], result: [*], #9]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [], result: , #0]
au.com.dius.pact.core.model.PathExpressionsSpec ‑ construct path from tokens [tokens: [a], result: a, #3]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a consumer from a Map [map: [:], consumer: Consumer(name=consumer), #0]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a consumer from a Map [map: [name:], consumer: Consumer(name=consumer), #2]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a consumer from a Map [map: [name:null], consumer: Consumer(name=consumer), #1]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a consumer from a Map [map: [name:test], consumer: Consumer(name=test), #3]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a provider from a Map [map: [:], provider: Provider(name=provider), #0]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a provider from a Map [map: [name:], provider: Provider(name=provider), #2]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a provider from a Map [map: [name:null], provider: Provider(name=provider), #1]
au.com.dius.pact.core.model.ProviderAndConsumerSpec ‑ creates a provider from a Map [map: [name:test], provider: Provider(name=test), #3]
au.com.dius.pact.core.model.ProviderStateSpec ‑ generates a map of the state [state: ProviderState(name=test, params={a=B, b=1, c=true}), map: [name:test, params:[a:B, b:1, c:true]], #2]
au.com.dius.pact.core.model.ProviderStateSpec ‑ generates a map of the state [state: ProviderState(name=test, params={a=au.com.dius.pact.core.model.ProviderStateSpec$Pojo@1e258d3b}), map: [name:test, params:[a:[v:1, s:one, b:false, vals:[1, 2, three]]]], #4]
au.com.dius.pact.core.model.ProviderStateSpec ‑ generates a map of the state [state: ProviderState(name=test, params={a={b=[B, C]}}), map: [name:test, params:[a:[b:[B, C]]]], #3]
au.com.dius.pact.core.model.ProviderStateSpec ‑ generates a map of the state [state: ProviderState(name=test, params={}), map: [name:test], #0]
au.com.dius.pact.core.model.ProviderStateSpec ‑ generates a map of the state [state: ProviderState(name=test, params={}), map: [name:test], #1]
au.com.dius.pact.core.model.ProviderStateSpec ‑ uniqueKey should be deterministic
au.com.dius.pact.core.model.ProviderStateSpec ‑ uniqueKey should only include parameter keys
au.com.dius.pact.core.model.RequestResponseInteractionKtTest ‑ pactSpecVersionAtLeast()
au.com.dius.pact.core.model.RequestResponseInteractionKtTest ‑ pactSpecVersionLessThan()
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ correctly encodes the query parameters when V2 format
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ creates a V2 map format if not V3 spec
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ creates a V3 map format if UNSPECIFIED spec
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ creates a V3 map format if V3 spec
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ displayState test [providerStates: [ProviderState(name=, params={})], stateDescription: None, #1]
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ displayState test [providerStates: [ProviderState(name=state 1, params={}), ProviderState(name=state 2, params={})], stateDescription: state 1, state 2, #3]
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ displayState test [providerStates: [ProviderState(name=state 1, params={})], stateDescription: state 1, #2]
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ displayState test [providerStates: [], stateDescription: None, #0]
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ does not include a provide state if there is not any
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ supports empty bodies
au.com.dius.pact.core.model.RequestResponseInteractionSpec ‑ unique key test [interaction1: Interaction: description 1+2
	in states None
request:
	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, interaction2: Interaction: description 1+2
	in states None
request:
	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, interaction3: Interaction: description 1+2
	in states state 3
request:
	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, interaction4: Interaction: description 4
	in states None
request:
	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, interaction5: Interaction: description 4
	in states state 5
request:
	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ does not lose the scale for decimal numbers
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ equality test [pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ pacts are equal if the metadata is different [pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={meta=data}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), pact2: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={meta=other data}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ pacts are not equal if the consumers are different [consumer2: Consumer(name=other consumer), pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), pact2: BasePact(consumer=Consumer(name=other consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ pacts are not equal if the interactions are different [interaction2: Interaction: test
	in states None
request:
	method: POST
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {Content-Type=[application/json]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT({"value": 1234.0}), pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), pact2: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ pacts are not equal if the number of interactions are different [interaction2: Interaction: test
	in states None
request:
	method: POST
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING

response:
	status: 200
	headers: {Content-Type=[application/json]}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: PRESENT({"value": 1234.0}), pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), pact2: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ pacts are not equal if the providers are different [provider2: Provider(name=other provider), pact: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), pact2: BasePact(consumer=Consumer(name=consumer), provider=Provider(name=other provider), metadata={pactSpecification={version=4.0}, pact-jvm={version=}}, source=au.com.dius.pact.core.model.UnknownPactSource@5b88af70), #0]
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ should handle body types other than JSON
au.com.dius.pact.core.model.RequestResponsePactSpec ‑ when writing V2 spec, query parameters must be encoded appropriately
au.com.dius.pact.core.model.RequestSpec ‑ delegates to the matching rules to parse matchers
au.com.dius.pact.core.model.RequestSpec ‑ detects multipart file uploads based on the content type [contentType: MULTIPART/FORM-DATA; boundary=boundaryMarker, multipartFileUpload: true, #4]
au.com.dius.pact.core.model.RequestSpec ‑ detects multipart file uploads based on the content type [contentType: multipart/form-data, multipartFileUpload: true, #0]
au.com.dius.pact.core.model.RequestSpec ‑ detects multipart file uploads based on the content type [contentType: multipart/form-data; boundary=boundaryMarker, multipartFileUpload: true, #2]
au.com.dius.pact.core.model.RequestSpec ‑ detects multipart file uploads based on the content type [contentType: multipart/form-data;boundary=boundaryMarker, multipartFileUpload: true, #3]
au.com.dius.pact.core.model.RequestSpec ‑ detects multipart file uploads based on the content type [contentType: text/plain, multipartFileUpload: false, #1]
au.com.dius.pact.core.model.RequestSpec ‑ fromMap sets defaults for attributes missing from the map [request: 	method: GET
	path: /
	query: {}
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, #0]
au.com.dius.pact.core.model.RequestSpec ‑ handles the cookie header
au.com.dius.pact.core.model.RequestSpec ‑ handles the cookie header with multiple values
au.com.dius.pact.core.model.RequestSpec ‑ when loading from json, do not split header values
au.com.dius.pact.core.model.ResponseSpec ‑ delegates to the matching rules to parse matchers
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap sets defaults for attributes missing from the map [response: 	status: 200
	headers: {}
	matchers: MatchingRules(rules={})
	generators: Generators(categories={})
	body: MISSING, #0]
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap should handle different number types [statusValue: 200, #0]
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap should handle different number types [statusValue: 200, #1]
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap should handle different number types [statusValue: 200, #4]
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap should handle different number types [statusValue: 200.0, #2]
au.com.dius.pact.core.model.ResponseSpec ‑ fromMap should handle different number types [statusValue: 200.0, #3]
au.com.dius.pact.core.model.ResponseSpec ‑ when loading from json, do not split header values
au.com.dius.pact.core.model.SynchronousHttpSpec ‑ allows configuring the interaction from properties
au.com.dius.pact.core.model.V3PactSpec ‑ refuse to merge pacts with different spec versions
au.com.dius.pact.core.model.V3PactSpec ‑ refuse to merge pacts with different types (message vs request-response)
au.com.dius.pact.core.model.V3PactSpec ‑ when merging it should replace messages with the same description and state
au.com.dius.pact.core.model.V3PactSpec ‑ writing pacts should merge with any existing file
au.com.dius.pact.core.model.V4InteractionSpec ‑ when downgrading message to V4, rename the matching rules from content to body
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: "ABC", encoding: JSON, contentType: application/json, body: PRESENT("ABC"), #5]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: "ABC", encoding: false, contentType: application/json, body: PRESENT("\"ABC\""), #3]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: "ABC", encoding: json, contentType: application/json, body: PRESENT("ABC"), #4]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: ABC, encoding: false, contentType: application/json, body: PRESENT("ABC"), #2]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: IkFCQyI=, encoding: BASE64, contentType: application/json, body: PRESENT("ABC"), #8]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: IkFCQyI=, encoding: base64, contentType: application/json, body: PRESENT("ABC"), #7]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: IkFCQyI=, encoding: true, contentType: application/json, body: PRESENT("ABC"), #6]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: {}, encoding: false, contentType: , body: PRESENT({}), #1]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - handling different types of encoding [content: {}, encoding: false, contentType: application/json, body: PRESENT({}), #0]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - when body is empty in the Pact file [json: [:], body: MISSING, #0]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - when body is empty in the Pact file [json: [body:], body: EMPTY, #2]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - when body is empty in the Pact file [json: [body:null], body: NULL, #1]
au.com.dius.pact.core.model.V4PactKtSpec ‑ bodyFromJson - when body is empty in the Pact file [json: [body:{"content":""}], body: EMPTY, #3]
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 combined pact
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 message pact
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 pact
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 pact with comments
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 pact with message with comments
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 pact with pending interactions
au.com.dius.pact.core.model.V4PactSpec ‑ test load v4 synchronous messages pact
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression error test [expression: +, expected: Error parsing expression: Was expecting an integer at index 1, #0]
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression error test [expression: now +, expected: Error parsing expression: Was expecting an integer at index 5, #1]
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression error test [expression: tomorr, expected: ^Error parsing expression.*, #2]
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - 
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - + 1 day
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - + 1 day - 2 weeks
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - + 1 week
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - + 4 years
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - - 2 weeks
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - last december
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - last december + 2 weeks + 4 days
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - last mon + 2 weeks
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - last month
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - last wednesday
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next fortnight
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next jan
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next june + 2 weeks
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next mon
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next monday
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - next week
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - now
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - today
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - tomorrow
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - tomorrow+ 4 years
au.com.dius.pact.core.model.generators.DateExpressionSpec ‑ date expression test - yesterday
au.com.dius.pact.core.model.generators.DateGeneratorSpec ‑ Uses any defined expression to generate the date value [date: 2024-02-17, #0]
au.com.dius.pact.core.model.generators.DateGeneratorSpec ‑ Uses json deserialization to work correctly with optional format fields
au.com.dius.pact.core.model.generators.DateGeneratorSpec ‑ supports timezones
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ Time expressions that cause the date to roll [base: 2020-04-14T23:20:00.311Z, datetime: 2020-04-16T00:20:00.311Z, #0]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - 
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - + 1 day
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - + 1 day - 2 weeks
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - + 1 week
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - + 4 years
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - - 2 weeks
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - last december
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - last december + 2 weeks + 4 days
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - last mon + 2 weeks
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - last month
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - last wednesday
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next fortnight
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next jan
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next june + 2 weeks
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next mon
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next monday
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - next week
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - now
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - today
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - tomorrow
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - tomorrow+ 4 years
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ date expression test - yesterday
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: + @ +, expected: Error parsing expression: Was expecting an integer at index 2, Error parsing expression: Was expecting an integer at index 5, #4]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: +, expected: Error parsing expression: Was expecting an integer at index 1, #0]

au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: now +, expected: Error parsing expression: Was expecting an integer at index 5, #1]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: now @ +, expected: Error parsing expression: Was expecting an integer at index 7, #3]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: now @ noo, expected: ^Error parsing expression.*, #7]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: now @ now +, expected: Error parsing expression: Was expecting an integer at index 11, #6]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: now+ @ now +, expected: Error parsing expression: Was expecting an integer at index 5, Error parsing expression: Was expecting an integer at index 12, #5]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression error test [expression: tomorr, expected: ^Error parsing expression.*, #2]
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - + 1 day @ noon
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - + 1 week @ +1 hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - + 4 years @ midnight
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - - 2 weeks @ now + 1 hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - last month @ last hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - next week @ next hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - today @ 1 o'clock
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - tomorrow @ now
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - tomorrow+ 4 years @ 3 o'clock + 40 milliseconds
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - yesterday @ midnight
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ datetime expression test - yesterday @ midnight - 1 hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @  + 2 hours - 4 minutes
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ + 1 hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ + 4 milliseconds
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ + 4 seconds
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ - 2 minutes
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ 1 o'clock pm
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ 12 o'clock am
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ 2 o'clock
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ last minute
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ midnight
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ midnight+ 4 minutes
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ next hour
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ noon
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ now
au.com.dius.pact.core.model.generators.DateTimeExpressionSpec ‑ time expression test - @ now + 2 hours - 4 minutes
au.com.dius.pact.core.model.generators.DateTimeGeneratorSpec ‑ Uses any defined expression to generate the datetime value [base: 2024-02-16T04:01:54.135059411Z, datetime: 2024-02-17T05:01:54+0000, #0]
au.com.dius.pact.core.model.generators.DateTimeGeneratorSpec ‑ Uses json deserialization to work correctly with optional format fields
au.com.dius.pact.core.model.generators.DateTimeGeneratorSpec ‑ supports timezones
au.com.dius.pact.core.model.generators.DateTimeGeneratorSpec ‑ supports timezones with zone IDs
au.com.dius.pact.core.model.generators.FormUrlEncodedContentTypeHandlerSpec ‑ applies the generator to all map entries
au.com.dius.pact.core.model.generators.FormUrlEncodedContentTypeHandlerSpec ‑ applies the generator to the field in the body
au.com.dius.pact.core.model.generators.FormUrlEncodedContentTypeHandlerSpec ‑ does not apply the generator to empty body
au.com.dius.pact.core.model.generators.FormUrlEncodedContentTypeHandlerSpec ‑ does not apply the generator when field is not in the body
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators defaults to the generators model package if not found [packages: , #1]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators defaults to the generators model package if not found [packages: au.com.dius.pact.core.model.generators.test.pkg1, #3]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators defaults to the generators model package if not found [packages: au.com.dius.pact.core.model.generators.test.pkgX, #2]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators defaults to the generators model package if not found [packages: null, #0]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators looks for the generator in the pact.generators.packages system property [type: Pkg1, generatorClass: au.com.dius.pact.core.model.generators.test.pkg1.Pkg1Generator, #0]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators looks for the generator in the pact.generators.packages system property [type: Pkg2, generatorClass: au.com.dius.pact.core.model.generators.test.pkg2.Pkg2Generator, #1]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ find generators looks for the generator in the pact.generators.packages system property [type: Pkg3, generatorClass: au.com.dius.pact.core.model.generators.test.pkg3.Pkg3Generator, #2]
au.com.dius.pact.core.model.generators.GeneratorKtSpec ‑ throws a class not found exception if the generator was not found
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ doesn't invoke the provided closure if not in the appropriate mode
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: EMPTY, contentType: text/plain, returnedBody: EMPTY, #0]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: MISSING, contentType: text/plain, returnedBody: MISSING, #1]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: NULL, contentType: text/plain, returnedBody: NULL, #2]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: PRESENT(text), contentType: application/json, returnedBody: PRESENT(JSON), #4]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: PRESENT(text), contentType: application/xml, returnedBody: PRESENT(XML), #5]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ for bodies, the generator is applied based on the content type [body: PRESENT(text), contentType: text/plain, returnedBody: PRESENT(text), #3]
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ generators invoke the provided closure for each key-value pair
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ handle the case of categories that do not have sub-keys
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - body
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - empty map
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - header
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - invalid generator class
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - invalid map entry
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - invalid map key
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - method
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - null map
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - path
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - query
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ load generator from map - status
au.com.dius.pact.core.model.generators.GeneratorsSpec ‑ when re-keying the generators, drop any dollar from the start
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to a list item
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to a map entry
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to all list items
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to all map entries
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to the object graph
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to the object graph with wildcard
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ applies the generator to the root
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ does not apply the generator if the index is not in the list
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ does not apply the generator to the object graph when the expression does not match
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ does not apply the generator when field is not in map
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ does not apply the generator when not a list
au.com.dius.pact.core.model.generators.JsonContentTypeHandlerSpec ‑ does not apply the generator when not a map
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ examples from Pact Compatability Suite
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when the example value does not match
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when the mock server details has no URL
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when the mock server details is empty
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when the mock server details is invalid
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when the test context is empty
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ generate returns null when there is no mock server details in the test context
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ replaces the non-matching parts with the mock server base URL [context: [mockServer:[href:http://mockserver/]], #1]
au.com.dius.pact.core.model.generators.MockServerURLGeneratorSpec ‑ replaces the non-matching parts with the mock server base URL [context: [mockServer:[href:http://mockserver]], #0]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ fromJson test
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ fromJson updates the expressions if the markers are overridden
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ handles encoded values in the expressions
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ parsers any expressions from the context [context: [a:100], expression: a, value: 100, #1]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ parsers any expressions from the context [context: [a:A, b:100], expression: /${a}/${b}, value: /A/100, #2]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ parsers any expressions from the context [context: [a:A, b:100], expression: /${a}/${c}, value: /A/, #3]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ parsers any expressions from the context [context: [a:A], expression: a, value: A, #0]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ toMap restores the expressions if the markers are overridden
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ toMap test
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ uses the provider state map from the context [context: [:], value: null, #0]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ uses the provider state map from the context [context: [providerState:[:]], value: null, #2]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ uses the provider state map from the context [context: [providerState:[a:Value]], value: Value, #3]
au.com.dius.pact.core.model.generators.ProviderStateGeneratorSpec ‑ uses the provider state map from the context [context: [providerState:test], value: null, #1]
au.com.dius.pact.core.model.generators.RandomDecimalGeneratorSpec ‑ generates a value with a decimal point and only a leading zero if the point is in the second position
au.com.dius.pact.core.model.generators.RandomDecimalGeneratorSpec ‑ handle edge case when digits == 1
au.com.dius.pact.core.model.generators.RandomDecimalGeneratorSpec ‑ handle edge case when digits == 2
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression error test [expression: +, expected: Error parsing expression: Was expecting an integer at index 1, #0]
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression error test [expression: noo, expected: ^Error parsing expression.*, #2]
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression error test [expression: now +, expected: Error parsing expression: Was expecting an integer at index 5, #1]
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - 
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test -  + 2 hours - 4 minutes
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - + 1 hour
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - + 4 milliseconds
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - + 4 seconds
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - - 2 minutes
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - 1 o'clock
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - 1 o'clock am
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - 1 o'clock pm
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - last minute
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - midnight
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - midnight+ 4 minutes
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - next hour
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - noon
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - now
au.com.dius.pact.core.model.generators.TimeExpressionSpec ‑ time expression test - now + 2 hours - 4 minutes
au.com.dius.pact.core.model.generators.TimeGeneratorSpec ‑ Uses any defined expression to generate the time value [base: 2024-02-16T04:01:54.383866957Z, time: 05:01:54, #0]
au.com.dius.pact.core.model.generators.TimeGeneratorSpec ‑ Uses json deserialization to work correctly with optional format fields
au.com.dius.pact.core.model.generators.TimeGeneratorSpec ‑ supports timezones
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ default format is lowercase hyphenated
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [:], generator: UuidGenerator(format=null), #0]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [format:URN], generator: UuidGenerator(format=URN), #4]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [format:lower-case-hyphenated], generator: UuidGenerator(format=lower-case-hyphenated), #2]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [format:other], generator: UuidGenerator(format=null), #5]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [format:simple], generator: UuidGenerator(format=simple), #1]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ from JSON [json: [format:upper-case-hyphenated], generator: UuidGenerator(format=upper-case-hyphenated), #3]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ lowercase hyphenated
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ simple
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ to JSON [generator: UuidGenerator(format=URN), json: [type:Uuid, format:URN], #4]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ to JSON [generator: UuidGenerator(format=lower-case-hyphenated), json: [type:Uuid, format:lower-case-hyphenated], #2]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ to JSON [generator: UuidGenerator(format=null), json: [type:Uuid], #0]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ to JSON [generator: UuidGenerator(format=simple), json: [type:Uuid, format:simple], #1]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ to JSON [generator: UuidGenerator(format=upper-case-hyphenated), json: [type:Uuid, format:upper-case-hyphenated], #3]
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ uppercase hyphenated
au.com.dius.pact.core.model.generators.UuidGeneratorSpec ‑ urn
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ generate V1 format body matchers
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ generate V1_1 format body matchers
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ generate V2 format body matchers
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ generate V3 format body matchers
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ loading matching rules from JSON
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ orElse can default to another rule set if empty
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ when re-keying the matchers, always prepend prefix to existing key
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ when re-keying the matchers, drop any dollar from the start
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ writes header matchers in the correct format
au.com.dius.pact.core.model.matchingrules.MatchingRuleCategorySpec ‑ writes path matchers in the correct format
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: <au.com.dius.pact.core.model.matchingrules.EqualsMatcher@51f4439e>, map: [match:equality], #0]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: <au.com.dius.pact.core.model.matchingrules.NullMatcher@6a7aa675>, map: [match:null], #12]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: <au.com.dius.pact.core.model.matchingrules.TypeMatcher@66dd04e2>, map: [match:type], #2]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: <au.com.dius.pact.core.model.matchingrules.ValuesMatcher@495e8a3>, map: [match:values], #11]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: DateMatcher(format=yyyy-MM-dd), map: [match:date, format:yyyy-MM-dd], #9]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: IncludeMatcher(value=A), map: [match:include, value:A], #10]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: MaxTypeMatcher(max=1), map: [match:type, max:1], #5]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: MinMaxTypeMatcher(min=2, max=3), map: [match:type, max:3, min:2], #6]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: MinTypeMatcher(min=1), map: [match:type, min:1], #4]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: NumberTypeMatcher(numberType=DECIMAL), map: [match:type], #3]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: RegexMatcher(regex=.*, example=null), map: [match:regex, regex:.*], #1]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: TimeMatcher(format=HH:mm:ss), map: [match:time, format:HH:mm:ss], #8]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ Converts number matchers to type matchers when spec is < V3 [matcher: TimestampMatcher(format=yyyy-MM-dd HH:mm:ssZZZZZ), map: [match:timestamp, format:yyyy-MM-dd HH:mm:ssZZZZZ], #7]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ defaults to AND for combining rules
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [:], value: MatchingRuleGroup(rules=[], ruleLogic=AND, cascaded=false), #0]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [matchers:[[match:equality]], combine:AND], value: MatchingRuleGroup(rules=[au.com.dius.pact.core.model.matchingrules.EqualsMatcher@51f4439e], ruleLogic=AND, cascaded=false), #3]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [matchers:[[match:equality]], combine:BAD], value: MatchingRuleGroup(rules=[au.com.dius.pact.core.model.matchingrules.EqualsMatcher@51f4439e], ruleLogic=AND, cascaded=false), #5]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [matchers:[[match:equality]], combine:OR], value: MatchingRuleGroup(rules=[au.com.dius.pact.core.model.matchingrules.EqualsMatcher@51f4439e], ruleLogic=OR, cascaded=false), #4]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [matchers:[[match:equality]]], value: MatchingRuleGroup(rules=[au.com.dius.pact.core.model.matchingrules.EqualsMatcher@51f4439e], ruleLogic=AND, cascaded=false), #2]
au.com.dius.pact.core.model.matchingrules.MatchingRuleGroupSpec ‑ from JSON [json: [other:value], value: MatchingRuleGroup(rules=[], ruleLogic=AND, cascaded=false), #1]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Array contains matcher to map for JSON
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Load array contains matcher from json
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Load status code matcher from json
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:date, date:yyyy-MM-dd], matcher: DateMatcher(format=yyyy-MM-dd), #4]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:date, format:yyyy-MM-dd], matcher: DateMatcher(format=yyyy-MM-dd), #5]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:date], matcher: DateMatcher(format=yyyy-MM-dd), #3]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:time, format:HH:mm], matcher: TimeMatcher(format=HH:mm), #8]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:time, time:HH:mm], matcher: TimeMatcher(format=HH:mm), #7]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:time], matcher: TimeMatcher(format=HH:mm:ss), #6]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:timestamp, format:yyyy-MM-dd], matcher: TimestampMatcher(format=yyyy-MM-dd), #2]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:timestamp, timestamp:yyyy-MM-dd], matcher: TimestampMatcher(format=yyyy-MM-dd), #1]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ Loading Date/Time matchers [map: [match:timestamp], matcher: TimestampMatcher(format=yyyy-MM-dd HH:mm:ssZZZZZ), #0]
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ With V2 format, matching rules for headers are pluralised
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ With V2 format, matching rules for queries should be encoded correctly
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ With V3 format, matching rules for queries should not be encoded
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ date/time matcher to json
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ do not include empty categories
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ fromMap handles a null map
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ fromMap handles an empty map
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ generates path matching rules in the correct format
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ loads V2 matching rules
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ loads V2 query matching rules that are encoded
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ loads V3 matching rules
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ loads matching rules affected by defect #743
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns DateMatcher if the matcher definition contains a date
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns DateMatcher if the matcher type is 'date'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns EqualsIgnoreOrderMatcher if the matcher type is 'ignore-order' and there is no min or max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns EqualsMatcher if the definition is empty
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns EqualsMatcher if the definition is invalid
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns EqualsMatcher if the matcher type is equality
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns EqualsMatcher if the matcher type is unknown
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns IncludeMatcher if the matcher type is include
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MaxEqualsIgnoreOrderMatcher if the matcher type is 'ignore-order' and there is a max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MaxTypeMatcher if the matcher definition contains a max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MaxTypeMatcher if the matcher type is 'max'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MaxTypeMatcher if the matcher type is 'type' and there is a max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinEqualsIgnoreOrderMatcher if the matcher type is 'ignore-order' and there is a min
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinMaxEqualsIgnoreOrderMatcher if the matcher type is 'ignore-order' and there is a min and max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinMaxTypeMatcher if the matcher definition contains both a min and max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinTypeMatcher if the matcher definition contains a min
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinTypeMatcher if the matcher type is 'min'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns MinTypeMatcher if the matcher type is 'type' and there is a min
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns NumberTypeMatcher if the matcher type is 'decimal'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns NumberTypeMatcher if the matcher type is 'integer'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns NumberTypeMatcher if the matcher type is 'number'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns NumberTypeMatcher if the matcher type is 'real'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns RegexMatcher if the matcher definition contains a regex
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns RegexMatcher if the matcher type is regex
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns TimeMatcher if the matcher definition contains a time
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns TimeMatcher if the matcher type is 'time'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns TimestampMatcher if the matcher definition contains a timestamp
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns TimestampMatcher if the matcher type is 'timestamp'
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns TypeMatcher if the matcher type is 'type' and there is no min or max
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ matchers fromJson returns ValuesMatcher if the matcher type is values
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ renaming categories
au.com.dius.pact.core.model.matchingrules.MatchingRulesSpec ‑ status code matcher to map for JSON
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ each key and value [expression: eachKey(matching(regex, '$(\.\w+)+', '$.test.one')), value: [A(value=EachKeyMatcher(definition=MatchingRuleDefinition(value=$.test.one, valueType=Unknown, rules=[A(value=RegexMatcher(regex=$(\.\w+)+, example=null))], generator=null)))], #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ each key and value [expression: eachKey(notEmpty('$.test')), eachValue(matching(number, 100)), value: [A(value=EachKeyMatcher(definition=MatchingRuleDefinition(value=$.test, valueType=String, rules=[A(value=au.com.dius.pact.core.model.matchingrules.NotEmptyMatcher@75d7297d)], generator=null))), A(value=EachValueMatcher(definition=MatchingRuleDefinition(value=100, valueType=Unknown, rules=[A(value=NumberTypeMatcher(numberType=NUMBER))], generator=null)))], #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ each key and value [expression: eachValue(matching($'items')), value: [A(value=EachValueMatcher(definition=MatchingRuleDefinition(value=null, valueType=Unknown, rules=[B(value=MatchingReference(name=items))], generator=null)))], #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ if the string does not start with a valid matching definition [expression: , #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ if the string does not start with a valid matching definition [expression: a, b, c, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ if the string does not start with a valid matching definition [expression: matching some other text, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast(), error: Error parsing expression: Was expecting an unsigned number at index 8, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast(, error: Error parsing expression: Was expecting an unsigned number at index 8, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast(-10), error: Error parsing expression: Was expecting an unsigned number at index 8, #4]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast(0.1), error: Error parsing expression: Was expecting a ')' at index 9, #5]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast(100, error: Error parsing expression: Was expecting a ')' at index 11, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atLeast matcher [expression: atLeast, error: Error parsing expression: Was expecting a '(' at index 7, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost(), error: Error parsing expression: Was expecting an unsigned number at index 7, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost(, error: Error parsing expression: Was expecting an unsigned number at index 7, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost(-10), error: Error parsing expression: Was expecting an unsigned number at index 7, #4]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost(0.1), error: Error parsing expression: Was expecting a ')' at index 8, #5]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost(100, error: Error parsing expression: Was expecting a ')' at index 10, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid atMost matcher [expression: atMost, error: Error parsing expression: Was expecting a '(' at index 6, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid each key and value [expression: eachKey(regex, '$(\.\w+)+', '$.test.one'), #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid each key and value [expression: eachValue(number, 10), #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid number matcher [expression: matching(integer,100.101), #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ invalid regex matcher [expression: matching(regex, null, 'Fred'), #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse atLeast matcher [expression: atLeast( 22 ), value: 22, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse atLeast matcher [expression: atLeast(100), value: 100, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse atMost matcher [expression: atMost( 22 ), value: 22, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse atMost matcher [expression: atMost(100), value: 100, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse boolean matcher [expression: matching( boolean , false ), value: false, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse boolean matcher [expression: matching(boolean, true), value: true, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse datetime matcher [expression: matching( time , 'HH:mm:ss' , '12:00:00' ), format: HH:mm:ss, value: 12:00:00, matcherClass: class au.com.dius.pact.core.model.matchingrules.TimeMatcher, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse datetime matcher [expression: matching(date, 'yyyy-MM-dd','2000-01-01'), format: yyyy-MM-dd, value: 2000-01-01, matcherClass: class au.com.dius.pact.core.model.matchingrules.DateMatcher, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse datetime matcher [expression: matching(datetime, 'yyyy-MM-dd HH:mm:ss','2000-01-01 12:00:00'), format: yyyy-MM-dd HH:mm:ss, value: 2000-01-01 12:00:00, matcherClass: class au.com.dius.pact.core.model.matchingrules.TimestampMatcher, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse datetime matcher [expression: matching(time, 'HH:mm:ss','12:00:00'), format: HH:mm:ss, value: 12:00:00, matcherClass: class au.com.dius.pact.core.model.matchingrules.TimeMatcher, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse include matcher [expression: matching( include , 'Fred and Bob' ), value: Fred and Bob, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse include matcher [expression: matching(include, 'Fred and Bob'), value: Fred and Bob, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse notEmpty matcher [expression: notEmpty( 'true' ), value: true, type: String, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse notEmpty matcher [expression: notEmpty('true'), value: true, type: String, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse notEmpty matcher [expression: notEmpty(true), value: true, type: Boolean, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse number matcher [expression: matching( number , 100 ), value: 100, matcher: NUMBER, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse number matcher [expression: matching(decimal,100.101), value: 100.101, matcher: DECIMAL, #4]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse number matcher [expression: matching(integer,100), value: 100, matcher: INTEGER, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse number matcher [expression: matching(number, -100.101), value: -100.101, matcher: NUMBER, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse number matcher [expression: matching(number,100), value: 100, matcher: NUMBER, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse regex matcher [expression: matching( regex , '\w+' , 'Fred' ), regex: \w+, value: Fred, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse regex matcher [expression: matching(regex, '\w+','Fred'), regex: \w+, value: Fred, #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse type matcher [expression: matching( type , 'Name' ) , #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parse type matcher [expression: matching(type,'Name'), #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '', result: , #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '2020-05-21 16:44:32+10:00', result: 2020-05-21 16:44:32+10:00, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '<?xml?><test/>', result: <?xml?><test/>, #5]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: 'Example value', result: Example value, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\$(\.\w+)+', result: \$(\.\w+)+, #6]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\b backspace', result: ? backspace, #8]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\f formfeed', result: ? formfeed, #9]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\n linefeed', result: 
 linefeed, #10]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\r carriage return', result: 
 carriage return, #11]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\t tab', result: 	 tab, #12]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\u0109 unicode hex code', result: ĉ unicode hex code, #13]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\u{1D400} unicode hex code', result: \U0001d400 unicode hex code, #15]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\u{1DF0B} unicode hex code', result: \U0001df0b unicode hex code, #14]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: '\w{3}\d+', result: \w{3}\d+, #4]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: 'we don\'t currently support parallelograms', result: we don\'t currently support parallelograms, #7]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ parsing string values [expression: 'yyyy-MM-dd HH:mm:ssZZZZZ', result: yyyy-MM-dd HH:mm:ssZZZZZ, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string [expression: , result: , #0]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string [expression: Example value, result: Example value, #1]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string [expression: escaped \\, result: escaped \, #3]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string [expression: not escaped \$(\.\w+)+, result: not escaped \$(\.\w+)+, #2]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string [expression: slash at end \, result: slash at end \, #4]
au.com.dius.pact.core.model.matchingrules.expressions.MatchingDefinitionParserSpec ‑ process raw string error test
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: Boolean, result: Boolean, #15]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: Decimal, result: Decimal, #35]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: Integer, result: Integer, #34]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: Number, result: Number, #33]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: String, result: String, #19]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Boolean, typeB: Unknown, result: Boolean, #9]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: Boolean, result: Decimal, #32]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: Decimal, result: Decimal, #14]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: Integer, result: Decimal, #31]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: Number, result: Decimal, #30]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: String, result: String, #18]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Decimal, typeB: Unknown, result: Decimal, #7]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: Boolean, result: Integer, #29]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: Decimal, result: Decimal, #28]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: Integer, result: Integer, #13]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: Number, result: Integer, #27]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: String, result: String, #17]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Integer, typeB: Unknown, result: Integer, #5]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: Boolean, result: Number, #26]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: Decimal, result: Decimal, #25]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: Integer, result: Integer, #24]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: Number, result: Number, #12]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: String, result: String, #16]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Number, typeB: Unknown, result: Number, #3]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: Boolean, result: String, #23]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: Decimal, result: String, #22]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: Integer, result: String, #21]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: Number, result: String, #20]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: String, result: String, #11]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: String, typeB: Unknown, result: String, #0]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: Boolean, result: Boolean, #8]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: Decimal, result: Decimal, #6]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: Integer, result: Integer, #4]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: Number, result: Number, #2]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: String, result: String, #1]
au.com.dius.pact.core.model.matchingrules.expressions.ValueTypeSpec ‑ merging types [typeA: Unknown, typeB: Unknown, result: Unknown, #10]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ equality test [pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ fails to convert the message to a Map if the target spec version is < 3
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ merge message pact - same [pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ merge message pact [newMessage1: Message(description='message', providerStates=[], contents=PRESENT(0 9 8 7), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), message2: Message(description='message2', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(0 9 8 7), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), Message(description='message2', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ pacts are equal if the metadata is different [pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={meta=data}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={meta=other data}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ pacts are not equal if the consumers are different [consumer2: Consumer(name=other consumer), pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=other consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ pacts are not equal if the interactions are different [message2: Message(description='message', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ pacts are not equal if the number of interactions are different [message2: Message(description='message', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), Message(description='message', providerStates=[], contents=PRESENT(A B C), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessagePactSpec ‑ pacts are not equal if the providers are different [provider2: Provider(name=other provider), pact: MessagePact(provider=Provider(name=provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), pact2: MessagePact(provider=Provider(name=other provider), consumer=Consumer(name=consumer), messages=[Message(description='message', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={})], metadata={pactSpecification={version=4.0}, pact-jvm={version=}}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ Uses V3 provider state format when converting to a map
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles contents in string form [body: , contentType: application/vnd.schemaregistry.v1+json, expectedContents: [], message: Message(description='test', providerStates=[], contents=EMPTY, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #4]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles contents in string form [body: 1 2 3 4, contentType: , expectedContents: [49, 32, 50, 32, 51, 32, 52], message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles contents in string form [body: 1 2 3 4, contentType: text/plain, expectedContents: [49, 32, 50, 32, 51, 32, 52], message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles contents in string form [body: {"A": "Value A"}, contentType: application/json, expectedContents: [123, 34, 65, 34, 58, 32, 34, 86, 97, 108, 117, 101, 32, 65, 34, 125], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #2]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles contents in string form [body: {"A": "Value A"}, contentType: application/vnd.schemaregistry.v1+json, expectedContents: [0, 0, 0, 0, 1, 123, 34, 65, 34, 58, 32, 34, 86, 97, 108, 117, 101, 32, 65, 34, 125], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsBytes handles no contents
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles contents in string form [body: , contentType: application/vnd.schemaregistry.v1+json, expectedContents: , message: Message(description='test', providerStates=[], contents=EMPTY, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #4]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles contents in string form [body: 1 2 3 4, contentType: , expectedContents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles contents in string form [body: 1 2 3 4, contentType: text/plain, expectedContents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles contents in string form [body: {"A": "Value A", "B": "Value B"}, contentType: application/json, expectedContents: {"A": "Value A", "B": "Value B"}, message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #2]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles contents in string form [body: {"A": "Value A"}, contentType: application/vnd.schemaregistry.v1+json, expectedContents: ?????{"A": "Value A"}, message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ contentsAsString handles no contents
au.com.dius.pact.core.model.messaging.MessageSpec ‑ defaults to V3 provider state format when converting from a map
au.com.dius.pact.core.model.messaging.MessageSpec ‑ delegates to the matching rules to parse matchers
au.com.dius.pact.core.model.messaging.MessageSpec ‑ falls back to V2 provider state format when converting from a map
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - 
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/hal+json; charset=UTF-8
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/json
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/json; charset=UTF-8
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/json;charset=UTF-8
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/octet-stream
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - application/octet-stream;charset=UTF-8
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - null
au.com.dius.pact.core.model.messaging.MessageSpec ‑ format contents should handle content types correctly - text/plain
au.com.dius.pact.core.model.messaging.MessageSpec ‑ get content type test [key: Content-Type, contentType: text/plain, result: text/plain, message: Message(description='Test', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={Content-Type=text/plain}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ get content type test [key: contentType, contentType: application/json, result: application/json, message: Message(description='Test', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/json}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ get content type test [key: contenttype, contentType: application/octet-stream, result: application/octet-stream, message: Message(description='Test', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contenttype=application/octet-stream}), #2]

au.com.dius.pact.core.model.messaging.MessageSpec ‑ get content type test [key: none, contentType: none, result: null, message: Message(description='Test', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={none=none}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ kafka schema registry content type should be handled - application/vnd.schemaregistry.v1+json
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: 1 2 3 4, contentType: , contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #4]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: 1 2 3 4, contentType: text/plain, contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: ????, contentType: application/octet-stream, contents: AQIDBA==, message: Message(description='test', providerStates=[], contents=PRESENT(4 bytes starting with 01020304...), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #5]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: {"A": "Value A", "B": "Value B"}, contentType: , contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: {"A": "Value A", "B": "Value B"}, contentType: application/json, contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with no metadata [body: {"A": "Value A", "B": "Value B"}, contentType: text/plain, contents: {"A": "Value A", "B": "Value B"}, message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #2]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: 1 2 3 4, contentType: , contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=}), #4]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: 1 2 3 4, contentType: text/plain, contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=text/plain}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: ????, contentType: application/octet-stream, contents: AQIDBA==, message: Message(description='test', providerStates=[], contents=PRESENT(4 bytes starting with 01020304...), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/octet-stream}), #5]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: {"A": "Value A", "B": "Value B"}, contentType: , contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: {"A": "Value A", "B": "Value B"}, contentType: application/json, contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/json}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly - with only metadata [body: {"A": "Value A", "B": "Value B"}, contentType: text/plain, contents: {"A": "Value A", "B": "Value B"}, message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=text/plain}), #2]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: 1 2 3 4, contentType: , contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=}), #3]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: 1 2 3 4, contentType: text/plain, contents: 1 2 3 4, message: Message(description='test', providerStates=[], contents=PRESENT(1 2 3 4), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=text/plain}), #2]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: ????, contentType: application/octet-stream, contents: AQIDBA==, message: Message(description='test', providerStates=[], contents=PRESENT(4 bytes starting with 01020304...), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/octet-stream}), #4]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: invalid json, contentType: application/vnd.schemaregistry.v1+json, contents: invalid json, message: Message(description='test', providerStates=[], contents=PRESENT(invalid json), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/vnd.schemaregistry.v1+json}), #6]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: {"A": "Value A", "B": "Value B"}, contentType: , contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=}), #1]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: {"A": "Value A", "B": "Value B"}, contentType: application/json, contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/json}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ message to map handles message content correctly [body: {"A": "Value A", "B": "Value B"}, contentType: application/vnd.schemaregistry.v1+json, contents: [A:Value A, B:Value B], message: Message(description='test', providerStates=[], contents=PRESENT({"A": "Value A", "B": "Value B"}), matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={contentType=application/vnd.schemaregistry.v1+json}), #5]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ should throw when kafka schema registry content does not start with magic bytes
au.com.dius.pact.core.model.messaging.MessageSpec ‑ unique key test [interaction1: Message(description='description 1+2', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), interaction2: Message(description='description 1+2', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), interaction3: Message(description='description 1+2', providerStates=[ProviderState(name=state 3, params={})], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), interaction4: Message(description='description 4', providerStates=[], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), interaction5: Message(description='description 4', providerStates=[ProviderState(name=state 5, params={})], contents=MISSING, matchingRules=MatchingRules(rules={}), generators=Generators(categories={}), metadata={}), #0]
au.com.dius.pact.core.model.messaging.MessageSpec ‑ when upgrading message to V4, rename the matching rules from body to content
au.com.dius.pact.core.pactbroker.ConsumerVersionSelectorSpec ‑ convert to JSON [tag: A, latest: false, consumer: Bob, fallback: null, json: {"consumer":"Bob","latest":false,"tag":"A"}, #3]
au.com.dius.pact.core.pactbroker.ConsumerVersionSelectorSpec ‑ convert to JSON [tag: A, latest: false, consumer: null, fallback: null, json: {"latest":false,"tag":"A"}, #2]
au.com.dius.pact.core.pactbroker.ConsumerVersionSelectorSpec ‑ convert to JSON [tag: A, latest: true, consumer: null, fallback: B, json: {"fallbackTag":"B","latest":true,"tag":"A"}, #1]
au.com.dius.pact.core.pactbroker.ConsumerVersionSelectorSpec ‑ convert to JSON [tag: A, latest: true, consumer: null, fallback: null, json: {"latest":true,"tag":"A"}, #0]
au.com.dius.pact.core.pactbroker.ConsumerVersionSelectorSpec ‑ convert to JSON [tag: null, latest: false, consumer: Bob, fallback: null, json: {"consumer":"Bob","latest":false}, #4]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ Handles responses with charset attributes
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: , options: [:], parsedUrl: , #0]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: http://docker:5000/pacts/provider/{a}{b}, options: [a:test/, b:b], parsedUrl: http://docker:5000/pacts/provider/test%2Fb, #6]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: http://docker:5000/pacts/provider/{provider}/latest, options: [:], parsedUrl: http://docker:5000/pacts/provider/%7Bprovider%7D/latest, #2]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: http://docker:5000/pacts/provider/{provider}/latest, options: [provider:test], parsedUrl: http://docker:5000/pacts/provider/test/latest, #3]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: http://docker:5000/{b}/provider/{a}/latest, options: [a:a, b:b], parsedUrl: http://docker:5000/b/provider/a/latest, #4]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: http://localhost:8080/123456, options: [:], parsedUrl: http://localhost:8080/123456, #1]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ can parse templated URLS correctly [url: {a}://docker:5000/pacts/provider/{b}/latest, options: [a:test, b:b], parsedUrl: test://docker:5000/pacts/provider/b/latest, #5]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ does not throw an exception if the required link is empty
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ don't decode/encode URLs from links
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ failure handling - body is a parsed json doc with errors
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ failure handling - body is a parsed json doc with no errors
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ failure handling - body is null
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ forAll calls the closure with each link data when the link is a collection
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ forAll calls the closure with the link data
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ forAll does nothing if there is no matching link
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ handles invalid URL characters when fetching documents from the broker
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ initialise request adds all the default headers to the request
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": "null"}, name: test, url: null, #2]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": null}, name: test, url: null, #1]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": "null" }}, name: test, url: null, #5]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": null }}, name: test, url: null, #4]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": { "blah": "123" } }}, name: test, url: null, #7]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": { "href": "123" } }}, name: test, url: 123, #8]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": { "href": 123 } }}, name: test, url: 123, #9]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": { "test": {} }}, name: test, url: null, #6]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {"_links": {}}, name: test, url: null, #3]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ link url test [json: {}, name: test, url: null, #0]
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ matches authentication scheme case insensitive
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ navigating with a base URL containing a path
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ populates the auth cache if preemptive authentication system property is enabled
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ post URL delegates to a handler if one is supplied
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ post URL returns a failure result if an exception is thrown
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ post URL returns failure if the response is 400
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ post URL returns success if the response is 200
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ retry strategy is added to execution chain of client
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ supports templated URLs with slashes in the expanded values
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ throws an exception if the _links is not found
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ throws an exception if the request fails
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ throws an exception if the required link is not found
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ throws an exception if the response is 404 Not Found
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ throws an exception if the response is not JSON
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ uploading a JSON doc
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ uploading a JSON doc returns an error
au.com.dius.pact.core.pactbroker.HalClientSpec ‑ uploading a JSON doc unsuccessful due to 409
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ No need to encode the provider name, consumer name, tags and version when uploading a pact
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can i deploy - should retry when there are unknown results
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query - encodes + correctly
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test 1 2 3, pacticipantVersion: , latest: UseLatest(latest=true), to: null, ignore: [], result: q[][pacticipant]=Test+1+2+3&latestby=cvp&q[][latest]=true&latest=true, #4]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env 1, mainBranch=null), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env+1, #13]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env1, mainBranch=null), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1, #11]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=tag1, environment=env1, mainBranch=null), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1&latest=true&tag=tag1, #12]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=tst 3/4, environment=null, mainBranch=null), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true&tag=tst+3%2F4, #7]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=tst, environment=null, mainBranch=null), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true&tag=tst, #3]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: null, ignore: [IgnoreSelector(name=bob, version=100)], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true&ignore[][pacticipant]=bob&ignore[][version]=100, #9]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: null, ignore: [IgnoreSelector(name=bob, version=null), IgnoreSelector(name=fred, version=null)], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true&ignore[][pacticipant]=bob&ignore[][pacticipant]=fred, #10]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: null, ignore: [IgnoreSelector(name=bob, version=null)], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true&ignore[][pacticipant]=bob, #8]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: null, ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&latest=true, #0]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatestTag(latestTag=tst 3/4), to: null, ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][tag]=tst+3%2F4&latest=true, #6]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatestTag(latestTag=tst), to: null, ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][tag]=tst&latest=true, #2]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: 1 0 0, latest: UseLatest(latest=false), to: null, ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][version]=1+0+0&latest=true, #5]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - matrix query [pacticipant: Test, pacticipantVersion: 100, latest: UseLatest(latest=false), to: null, ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][version]=100&latest=true, #1]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy - should return verificationResultUrl when there is one
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env 1, mainBranch=false), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env+1, #2]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env 1, mainBranch=true), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env+1&mainBranch=true&latest=true, #5]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env1, mainBranch=false), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1, #0]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=null, environment=env1, mainBranch=true), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1&mainBranch=true&latest=true, #3]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=tag1, environment=env1, mainBranch=false), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1&latest=true&tag=tag1, #1]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ can-i-deploy to main branch - matrix query [pacticipant: Test, pacticipantVersion: , latest: UseLatest(latest=true), to: To(tag=tag1, environment=env1, mainBranch=true), ignore: [], result: q[][pacticipant]=Test&latestby=cvp&q[][latest]=true&environment=env1&latest=true&tag=tag1&mainBranch=true&latest=true, #4]
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetches consumers with more than one tag successfully
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetches consumers with specified tag successfully
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetches provider pacts for verification based on selectors raw json configuration passed from cli
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching consumers with the new auth format
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching consumers with the old auth format
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors does not include wip pacts when pending parameter is false
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors falls back to the beta provider-pacts-for-verification link
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors falls back to the previous implementation if no link is available
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors includes providerVersionBranch when matchingBranch is set and pending status is false
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors includes wip pacts when parameter not blank
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors uses the provider-pacts-for-verification link and returns a list of results
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ fetching pacts with selectors when falling back to the previous implementation, use fallback tags if present
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ publishing pact with new publish endpoint
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ publishing pact with new publish endpoint - defaults to the consumer version system property
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ publishing pact with new publish endpoint - with the branch as a system property
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ publishing verification results with an exception should support any type of exception
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ returns an error when uploading a pact fails
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when falling back to the previous implementation, filter out null tag values from the selectors
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching a pact, return the results as a Map
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching consumers for an unknown provider, returns an empty pacts list
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching consumers with specified tag for an unknown provider, returns an empty pacts list
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching consumers with specified tag, does not decode the URLs to the pacts
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching consumers, does not decode the URLs to the pacts
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when fetching pacts fails with a certificate error
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing provider tags, return an Ok result if it succeeds
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing provider tags, return an error result if any tag fails
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing verification results, return a Err if the verification link has no href
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing verification results, return a Err if there is no verification link
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing verification results, return a Ok if the broker client returns success
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when publishing verification results, return a Ok if the links have different case
au.com.dius.pact.core.pactbroker.PactBrokerClientSpec ‑ when uploading a pact with tags, publish the tags first
au.com.dius.pact.core.pactbroker.PactBrokerClientTest ‑ retryWithWhenCountIsGreaterThanOneAndPredicateIsTrueRunsTheNumberOfTimeByTheCount()
au.com.dius.pact.core.pactbroker.PactBrokerClientTest ‑ retryWithWhenCountIsGreaterThanOneButPredicateIsFalseRunsOnce()
au.com.dius.pact.core.pactbroker.PactBrokerClientTest ‑ retryWithWhenCountIsGreaterThanOneRunsUntilThePredicateIsFalse()
au.com.dius.pact.core.pactbroker.PactBrokerClientTest ‑ retryWithWhenCountIsOneRunsOnce()
au.com.dius.pact.core.pactbroker.PactBrokerClientTest ‑ retryWithWhenCountIsZeroRunsOnce()
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang, interactionId=123}], description=), result2: Ok(interactionIds=[123]), result3: Failed(results=[{error=Bang, interactionId=123}], description=), #9]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=), result2: Failed(results=[Boom, Splat], description=), result3: Failed(results=[{error=Bang}, Boom, Splat], description=), #10]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=), result2: Failed(results=[Boom, Splat], description=B), result3: Failed(results=[{error=Bang}, Boom, Splat], description=B), #12]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=), result2: Ok(interactionIds=[123]), result3: Failed(results=[{error=Bang}, {interactionId=123}], description=), #8]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=), result2: Ok(interactionIds=[]), result3: Failed(results=[{error=Bang}], description=), #7]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=A), result2: Failed(results=[Boom, Splat], description=), result3: Failed(results=[{error=Bang}, Boom, Splat], description=A), #11]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=A), result2: Failed(results=[Boom, Splat], description=A), result3: Failed(results=[{error=Bang}, Boom, Splat], description=A), #14]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Failed(results=[{error=Bang}], description=A), result2: Failed(results=[Boom, Splat], description=B), result3: Failed(results=[{error=Bang}, Boom, Splat], description=A, B), #13]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123, 234]), result2: Failed(results=[{error=Bang, interactionId=456}, {error=err2, interactionId=234}], description=), result3: Failed(results=[{error=Bang, interactionId=456}, {error=err2, interactionId=234}, {interactionId=123}], description=), #17]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123, 234]), result2: Failed(results=[{error=Bang, interactionId=456}], description=), result3: Failed(results=[{error=Bang, interactionId=456}, {interactionId=123}, {interactionId=234}], description=), #16]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123, 234]), result2: Ok(interactionIds=[456]), result3: Ok(interactionIds=[123, 234, 456]), #15]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123]), result2: Failed(results=[{error=Bang, interactionId=123}], description=), result3: Failed(results=[{error=Bang, interactionId=123}], description=), #6]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123]), result2: Failed(results=[{error=Bang}], description=), result3: Failed(results=[{error=Bang}, {interactionId=123}], description=), #5]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123]), result2: Ok(interactionIds=[456]), result3: Ok(interactionIds=[123, 456]), #3]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[123]), result2: Ok(interactionIds=[]), result3: Ok(interactionIds=[123]), #2]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[]), result2: Failed(results=[{error=Bang}], description=), result3: Failed(results=[{error=Bang}], description=), #4]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[]), result2: Ok(interactionIds=[123]), result3: Ok(interactionIds=[123]), #1]
au.com.dius.pact.core.pactbroker.TestResultSpec ‑ merging results test [result1: Ok(interactionIds=[]), result2: Ok(interactionIds=[]), result3: Ok(interactionIds=[]), #0]
au.com.dius.pact.core.pactbroker.VerificationResultPayloadSpec ‑ exceptions should be serialised as a message and exception class
au.com.dius.pact.core.pactbroker.VerificationResultPayloadSpec ‑ handle body mismatches
au.com.dius.pact.core.pactbroker.VerificationResultPayloadSpec ‑ handle header mismatches
au.com.dius.pact.core.pactbroker.VerificationResultPayloadSpec ‑ include any successful interactions
au.com.dius.pact.core.pactbroker.VerificationResultPayloadSpec ‑ mismatches should be grouped by interaction
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - Extra path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - Full URL with spaces
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - Full url with the path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - URL with spaces
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - base ending in slash
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - just a path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - no port
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - normal URL
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - normal URL with no path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url - path with spaces
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - Extra path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - Full url with the path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - base ending in slash
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - just a path
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - no port
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - normal URL
au.com.dius.pact.core.pactbroker.util.HttpClientUtilsSpec ‑ build url when not encoding the path - normal URL with no path
au.com.dius.pact.core.support.AnnotationsSpec ‑ finds annotation on outer class
au.com.dius.pact.core.support.AnnotationsSpec ‑ finds annotation on outer class parent
au.com.dius.pact.core.support.AnnotationsSpec ‑ finds annotation on parent class
au.com.dius.pact.core.support.AnnotationsSpec ‑ finds annotation on provided class
au.com.dius.pact.core.support.AnnotationsSpec ‑ returns null if the annotation is not found
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: CONNECT, #5]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: DELETE, #4]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: GET, #0]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: HEAD, #1]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: OPTIONS, #7]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: PATCH, #8]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: POST, #2]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: PUT, #3]
au.com.dius.pact.core.support.HttpClientSpec ‑ http client should retry any requests for any method [method: TRACE, #6]
au.com.dius.pact.core.support.HttpClientSpec ‑ when creating a new http client, add any authentication as default headers
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: "a string value", value: a string value, #4]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: 100, value: 100, #1]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: 100.3, value: 100.3, #2]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: ["a string value", 2], value: [a string value, 2], #7]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: ["a string value"], value: [a string value], #6]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: [], value: [], #5]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: null, value: null, #0]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: true, value: true, #3]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: {"a": "A", "b": 1, "c": [100], "d": {"href": "blah"}}, value: [a:A, b:1, c:[100], d:[href:blah]], #9]
au.com.dius.pact.core.support.JsonSpec ‑ from JSON test [json: {}, value: [:], #8]
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - Null
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - boolean
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - float
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - integer
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - list
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - object
au.com.dius.pact.core.support.JsonSpec ‑ object to JSON string - string
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: "a string value", value: "a string value", #4]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: 100, value: 100, #1]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: 100.3, value: 100.3, #2]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: ["a string value", 2], value: [
  "a string value",
  2
], #7]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: ["a string value"], value: [
  "a string value"
], #6]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: [], value: [

], #5]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: null, value: null, #0]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: true, value: true, #3]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: {"a": "A", "b": 1, "c": [100], "d": {"href": "blah"}}, value: {
  "a": "A",
  "b": 1,
  "c": [
    100
  ],
  "d": {
    "href": "blah"
  }
}, #9]
au.com.dius.pact.core.support.JsonSpec ‑ pretty print test [json: {}, value: {

}, #8]
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - Boolean False
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - Boolean True
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - Json Null
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - Null
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - float
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - integer
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - list
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - object
au.com.dius.pact.core.support.JsonSpec ‑ toBoolean - string
au.com.dius.pact.core.support.JsonSpec ‑ toString - Boolean False
au.com.dius.pact.core.support.JsonSpec ‑ toString - Boolean True
au.com.dius.pact.core.support.JsonSpec ‑ toString - Json Null
au.com.dius.pact.core.support.JsonSpec ‑ toString - Null
au.com.dius.pact.core.support.JsonSpec ‑ toString - float
au.com.dius.pact.core.support.JsonSpec ‑ toString - integer
au.com.dius.pact.core.support.JsonSpec ‑ toString - list
au.com.dius.pact.core.support.JsonSpec ‑ toString - object
au.com.dius.pact.core.support.JsonSpec ‑ toString - string
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ deepMergeHandlesNull()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ deepMergeWithCollectionsRecursivelyMergesTheCollections()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ deepMergeWithCollectionsWithDifferentTypes()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ deepMergeWithEmptyMaps()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ deepMergeWithSimpleMaps()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ padToPadsTheArrayByCyclingTheElements()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ padToReturnsAnEmptyListWhenIfTheArrayIsEmpty()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ padToReturnsTheListIfTheArrayIsBiggerThanThePad()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ padToReturnsTheListIfTheArrayIsHasTheSameSizeAsThePad()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsACorrectlySizedListWhenTheListIsEmpty()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsACorrectlySizedListWhenTheListsHaveTheSameSize()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsACorrectlySizedListWhenTheOtherListIsBigger()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsACorrectlySizedListWhenTheOtherListIsEmpty()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsACorrectlySizedListWhenTheOtherListIsSmaller()
au.com.dius.pact.core.support.KotlinLanguageSupportTest ‑ zipAllReturnsAnEmptyListWhenBothListsAreEmpty()
au.com.dius.pact.core.support.UtilsSpec ‑ lookup value from environment - key is a system property
au.com.dius.pact.core.support.UtilsSpec ‑ lookup value from environment - key is an environment variable
au.com.dius.pact.core.support.UtilsSpec ‑ lookup value from environment - key is an environment variable 2
au.com.dius.pact.core.support.UtilsSpec ‑ lookup value from environment - key is not found
au.com.dius.pact.core.support.UtilsSpec ‑ lookup value from environment - snake-case value of key is an environment variable
au.com.dius.pact.core.support.UtilsSpec ‑ lookupInMap [map: [:], clazz: class java.lang.Boolean, defaultVal: true, value: true, #0]
au.com.dius.pact.core.support.UtilsSpec ‑ lookupInMap [map: [key:], clazz: class java.lang.Boolean, defaultVal: true, value: true, #1]
au.com.dius.pact.core.support.UtilsSpec ‑ lookupInMap [map: [key:false], clazz: class java.lang.Boolean, defaultVal: true, value: false, #2]
au.com.dius.pact.core.support.UtilsSpec ‑ lookupInMap [map: [key:null], clazz: class java.lang.Boolean, defaultVal: true, value: true, #3]
au.com.dius.pact.core.support.UtilsSpec ‑ permutations
au.com.dius.pact.core.support.UtilsSpec ‑ permutations when the first list is empty
au.com.dius.pact.core.support.UtilsSpec ‑ permutations when the lists are empty
au.com.dius.pact.core.support.UtilsSpec ‑ permutations when the second list is empty
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf ""
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "-1kb"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "-kb"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "100"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "22b"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "2KB"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "2kb"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "2mb"
au.com.dius.pact.core.support.UtilsSpec ‑ sizeOf "aksldjsk"
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: , error: Was expecting an integer at index 0, #0]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 0, error: Was expecting a '.' at index 1 but got the end of the input, #2]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 0sass, error: Was expecting a '.' at index 1 but got 's', #3]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100, error: Was expecting a '.' at index 3 but got the end of the input, #4]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100., error: Was expecting an integer at index 4, #5]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100.10., error: Was expecting an integer at index 7, #6]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100.10.1ss, error: Unexpected characters 'ss' at index 8, #9]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100.10.sss, error: Was expecting an integer at index 7, #8]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: 100.10x, error: Unexpected characters 'x' at index 6, #7]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse errors [version: sdsd, error: Was expecting an integer at index 0, #1]
au.com.dius.pact.core.support.VersionParserSpec ‑ parse full version
au.com.dius.pact.core.support.VersionParserSpec ‑ parse invalid version
au.com.dius.pact.core.support.VersionParserSpec ‑ parse major.minor version
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Does Not Modify Strings With No Expressions
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Handles Empty Expression
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Handles single value as list
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression:  ${value} ${value2} , result:  [value] [value2] , #4]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression:  ${value} , result:  [value] , #3]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression:  ${value}, result:  [value], #1]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression: $${value}}, result: $[value]}, #5]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression: ${value} , result: [value] , #2]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Replaces The Expression With System Properties [expression: ${value}, result: [value], #0]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ Throws An Exception On Unterminated Expressions
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ correctExpressionMarkers does nothing if the expression markers are not overridden
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ correctExpressionMarkers updates the end marker if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ correctExpressionMarkers updates the markers if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ correctExpressionMarkers updates the start marker if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ parseListExpression - Ignores empty values during compound expression processing
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ parseListExpression - Splits a compound expression value
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ parseListExpression - Splits several singular expression values
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ parseListExpression - trims whitespace from list items
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ supports overridden expression markers with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ toDefaultExpressions does nothing if the expression markers are not overridden
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ toDefaultExpressions restores the end marker if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ toDefaultExpressions restores the markers if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ toDefaultExpressions restores the start marker if overridden with sys prop
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: DECIMAL, result: 100.0, #11]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: DECIMAL, result: 100.0, #6]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: FLOAT, result: 100.0, #10]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: FLOAT, result: 100.0, #5]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: INTEGER, result: 100, #4]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: INTEGER, result: 100, #9]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: RAW, result: 100, #2]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: RAW, result: 100, #7]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: STRING, result: 100, #3]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: 100, type: STRING, result: 100, #8]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: string, type: RAW, result: string, #0]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with a defined type, converts the expression into the correct type [value: string, type: STRING, result: string, #1]
au.com.dius.pact.core.support.expressions.ExpressionParserSpec ‑ with overridden expression markers
au.com.dius.pact.core.support.json.JsonBuilderTest ‑ testBasicJson()
au.com.dius.pact.core.support.json.JsonBuilderTest ‑ testChildArrayJson()
au.com.dius.pact.core.support.json.JsonBuilderTest ‑ testChildMultiLevel()
au.com.dius.pact.core.support.json.JsonBuilderTest ‑ testChildObjectJson()
au.com.dius.pact.core.support.json.JsonBuilderTest ‑ testEmptyBuilder()
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid characters similar to false
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid characters similar to null
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid characters similar to true
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid exponent
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid number
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - invalid number 2
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - string with invalid escape
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - string with invalid escaped hex chars
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ invalid next token - unterminated string
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - array end
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - array start
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - colon
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - comma
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - decimal
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - decimal with exponent
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - decimal with exponent 2
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - digit
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - empty document
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - false value
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - integer
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - negative integer
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - null value
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - object end
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - object start
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - string
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - string with escaped chars
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - string with escaped hex chars
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - true value
au.com.dius.pact.core.support.json.JsonLexerSpec ‑ next token - whitespace
au.com.dius.pact.core.support.json.JsonParserSpec ‑ can parse a pact file
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - empty document
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid case
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid comma
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid end array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid end object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid object key
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - invalid value after other
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - minus with no following digits
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - missing colon
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - missing comma in array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - missing comma in object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - unterminated array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - unterminated object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - unterminated object key
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - unterminated string
au.com.dius.pact.core.support.json.JsonParserSpec ‑ invalid document - whitespace
au.com.dius.pact.core.support.json.JsonParserSpec ‑ parse a basic message pact
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - 2d array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - 2d object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - decimal
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - empty array
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - empty object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - empty string
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - false
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - integer
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - keys with special chars
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - null
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - object
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - object with decimal value 1
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - object with decimal value 2
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - string
au.com.dius.pact.core.support.json.JsonParserSpec ‑ valid document - true
au.com.dius.pact.core.support.json.JsonValueSpec ‑ serialise with special chars in keys
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [116, 114, 117, 101, 125], expected: [0, 0, 0, 0, 1, 116, 114, 117, 101, 125], #10]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], expected: [0, 0, 0, 0, 1, 123, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], #12]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 125], expected: [0, 0, 0, 0, 1, 123, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 125], #15]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101, 32, 34, 111, 116, 104, 101, 114, 34, 58, 32, 102, 97, 108, 115, 101, 125], expected: [0, 0, 0, 0, 1, 123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101, 32, 34, 111, 116, 104, 101, 114, 34, 58, 32, 102, 97, 108, 115, 101, 125], #17]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101], expected: [0, 0, 0, 0, 1, 123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101], #8]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 34, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], expected: [0, 0, 0, 0, 1, 123, 34, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], #13]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [123, 34, 110, 117, 92, 108, 108, 34, 58, 32, 116, 114, 117, 101, 125], expected: [0, 0, 0, 0, 1, 123, 34, 110, 117, 92, 108, 108, 34, 58, 32, 116, 114, 117, 101, 125], #14]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 32, 32, 32, 110, 117, 108, 108, 32, 116, 114, 117, 101], expected: [0, 0, 0, 0, 1, 32, 32, 32, 32, 32, 110, 117, 108, 108, 32, 116, 114, 117, 101], #5]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 32, 32, 32, 32, 32, 9, 10, 13], expected: [0, 0, 0, 0, 1, 32, 32, 32, 32, 32, 32, 32, 9, 10, 13], #2]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 32, 32, 32, 34, 110, 117, 108, 108, 32, 116, 114, 117, 101], expected: [0, 0, 0, 0, 1, 32, 32, 32, 32, 32, 34, 110, 117, 108, 108, 32, 116, 114, 117, 101], #6]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 32, 32, 32], expected: [0, 0, 0, 0, 1, 32, 32, 32, 32, 32], #0]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 45], expected: [0, 0, 0, 0, 1, 32, 32, 45], #3]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [32, 32, 9, 10, 13], expected: [0, 0, 0, 0, 1, 32, 32, 9, 10, 13], #1]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [49, 50, 51, 52, 44], expected: [0, 0, 0, 0, 1, 49, 50, 51, 52, 44], #11]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [49, 50, 93], expected: [0, 0, 0, 0, 1, 49, 50, 93], #9]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [78, 117, 108, 108], expected: [0, 0, 0, 0, 1, 78, 117, 108, 108], #4]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [91, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 93], expected: [0, 0, 0, 0, 1, 91, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 93], #16]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - Adds magic bytes to start of bytes [value: [91, 34, 110, 117, 108, 108, 34, 44, 32, 116, 114, 117, 101], expected: [0, 0, 0, 0, 1, 91, 34, 110, 117, 108, 108, 34, 44, 32, 116, 114, 117, 101], #7]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - returns empty bytes when input is empty
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytes - returns null when input is null
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:   	

, expected: ?????  	

, #1]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:        	

, expected: ?????       	

, #2]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:      "null true, expected: ?????     "null true, #6]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:      , expected: ?????     , #0]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:      null true, expected: ?????     null true, #5]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value:   -, expected: ?????  -, #3]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: 1234,, expected: ?????1234,, #11]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: 12], expected: ?????12], #9]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: Null, expected: ?????Null, #4]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: ["null" true], expected: ?????["null" true], #16]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: ["null", true, expected: ?????["null", true, #7]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: true}, expected: ?????true}, #10]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {"nu\ll": true}, expected: ?????{"nu\ll": true}, #14]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {"null" true}, expected: ?????{"null" true}, #15]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {"null": true "other": false}, expected: ?????{"null": true "other": false}, #17]

au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {"null": true, expected: ?????{"null": true, #8]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {"null: true}, expected: ?????{"null: true}, #13]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - Adds magic bytes to start of string [value: {null: true}, expected: ?????{null: true}, #12]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - returns empty string when input is empty
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ addMagicBytesToString - returns null when input is null
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [116, 114, 117, 101, 125], expected: [], #10]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], expected: [58, 32, 116, 114, 117, 101, 125], #12]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 125], expected: [108, 34, 32, 116, 114, 117, 101, 125], #15]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101, 32, 34, 111, 116, 104, 101, 114, 34, 58, 32, 102, 97, 108, 115, 101, 125], expected: [108, 34, 58, 32, 116, 114, 117, 101, 32, 34, 111, 116, 104, 101, 114, 34, 58, 32, 102, 97, 108, 115, 101, 125], #17]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 34, 110, 117, 108, 108, 34, 58, 32, 116, 114, 117, 101], expected: [108, 34, 58, 32, 116, 114, 117, 101], #8]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 34, 110, 117, 108, 108, 58, 32, 116, 114, 117, 101, 125], expected: [108, 58, 32, 116, 114, 117, 101, 125], #13]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [123, 34, 110, 117, 92, 108, 108, 34, 58, 32, 116, 114, 117, 101, 125], expected: [108, 108, 34, 58, 32, 116, 114, 117, 101, 125], #14]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 32, 32, 32, 110, 117, 108, 108, 32, 116, 114, 117, 101], expected: [110, 117, 108, 108, 32, 116, 114, 117, 101], #5]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 32, 32, 32, 32, 32, 9, 10, 13], expected: [32, 32, 9, 10, 13], #2]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 32, 32, 32, 34, 110, 117, 108, 108, 32, 116, 114, 117, 101], expected: [34, 110, 117, 108, 108, 32, 116, 114, 117, 101], #6]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 32, 32, 32], expected: [], #0]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 45], expected: [], #3]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [32, 32, 9, 10, 13], expected: [], #1]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [49, 50, 51, 52, 44], expected: [], #11]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [49, 50, 93], expected: [], #9]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [78, 117, 108, 108], expected: [], #4]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [91, 34, 110, 117, 108, 108, 34, 32, 116, 114, 117, 101, 93], expected: [108, 34, 32, 116, 114, 117, 101, 93], #16]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - removes the length of the magic bytes from the start of the input [value: [91, 34, 110, 117, 108, 108, 34, 44, 32, 116, 114, 117, 101], expected: [108, 34, 44, 32, 116, 114, 117, 101], #7]
au.com.dius.pact.core.support.json.KafkaSchemaRegistryWireFormatterSpec ‑ removeMagicBytes - returns null when input is null