}
    assert jsonable_encoder(model, include={"foo"}) == {"foo": "foo"}
    assert jsonable_encoder(model, exclude={"bla"}) == {"foo": "foo", "bar": "bar"}
    assert jsonable_encoder(model, include={}) == {}
    assert jsonable_encoder(model, exclude={}) == {
        "foo": "foo",
        "bar": "bar",
        "bla": "bla",
    }


@needs_pydanticv1
def test_custom_encoders():
    class safe_datetime(datetime):

        expect:
        def result = event.convert(input)
        result.response == null
        result.newPrompt == "Please enter a value between 1 and 4: "

        where:
        input | _
        'bla' | ''
        '1s'  | ''
        '0'   | ''
        '5'   | ''
        '-1'  | ''
    }

        expect:
        def result = event.convert(input)
        result.response == null
        result.newPrompt == "Please enter 'yes' or 'no': "

        where:
        input   | _
        ''      | _
        'bla'   | _
        'y'     | _
        'Y'     | _
        'ye'    | _
        'YES'   | _
        'n'     | _
        'N'     | _
        'NO'    | _
        'true'  | _
        'false' | _
    }

        expect:
        def result = event.convert(input)
        result.response == null
        result.newPrompt == "Please enter 'yes' or 'no' (default: 'yes'): "

        where:
        input  | _
        'bla'  | ''
        'nope' | ''
        'yep'  | ''
    }

        expect:
        def result = event.convert(input)
        result.response == null
        result.newPrompt == "Please enter an integer value (min: 2, default: 4): "

        where:
        input | _
        'bla' | ''
        '1s'  | ''
        '1 2' | ''
        Long.MAX_VALUE.toString() | ''
    }

    def "rejects input that is below minimum"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)

	JwtPubKeyExtraElements = `{ "keys": [ { "kid": "fakeKey1_1", "alg": "RS256", "kty": "RSA", "n": "abc", "e": "def", "bla": "blah" },
			{ "kid": "fakeKey1_2", "alg": "RS256", "kty": "RSA", "n": "123", "e": "456", "bla": "blah" } ] }`
)

// Wrap the original handler with a delay
func withDelay(handler http.Handler, delay time.Duration) http.Handler {

)

var (
	// Known unsupported path parameter ("/bla;foo") normalization for Tomcat.
	dotdotPwnIgnoreTomcat = []string{
		"/../private/secret.html;index.html <- VULNERABLE!",
		"/../private/secret.html;index.htm <- VULNERABLE!",
		"/..%5Cprivate%5Csecret.html;index.html <- VULNERABLE!",
		"/..%5Cprivate%5Csecret.html;index.htm <- VULNERABLE!",
	}
	// Known unsupported path parameter ("/bla;foo") normalization for Tomcat.

            // without kotlin-stdlib-jdk8 we get:
            // > Retrieving groups by name is not supported on this platform.

            val regex = Regex("(?<bla>.*)")
            val groups = regex.matchEntire("abc")?.groups
            println("*" + groups?.get("bla")?.value + "*")

            """
        )

        assertThat(
            build("help").output,
            containsString("*abc*")
        )

	NilOKFunc:                 func(s *int) bool { return s == nil },
	ErrFunc:                   func() (string, error) { return "bla", nil },
	PanicFunc:                 func() string { panic("test panic") },
	TooFewReturnCountFunc:     func() {},
	TooManyReturnCountFunc:    func() (string, error, int) { return "", nil, 0 },

	NilOKFunc:                 func(s *int) bool { return s == nil },
	ErrFunc:                   func() (string, error) { return "bla", nil },
	PanicFunc:                 func() string { panic("test panic") },
	Tmpl:                      Must(New("x").Parse("test template")), // "x" is the value of .X
}

var tSliceOfNil = []*T{nil}