}
    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)

)

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.

	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 },

		expectedErrors bool
	}{
		{name: "valid socket URL", criSocket: kubeadmapiv1.DefaultContainerRuntimeURLScheme + "://" + "/some/path", expectedErrors: false},
		{name: "unsupported URL scheme", criSocket: "bla:///some/path", expectedErrors: true},
		{name: "missing URL scheme", criSocket: "/some/path", expectedErrors: true},
		{name: "unparseable URL", criSocket: ":::", expectedErrors: true},

									if to.Config().DeployAsVM {
										continue
									}
									for _, instance := range to.Instances() {
										err := instance.UpdateWorkloadLabel(map[string]string{"foo": "bla"}, nil)
										if err != nil {
											t.Fatal(err)
										}
									}
								}
								newAuthzTest().
									From(from).
									To(to).
									Allow(c.allow).

								MatchType: &networking.StringMatch_Exact{
									Exact: "Bar",
								},
							},
						},
						WithoutHeaders: map[string]*networking.StringMatch{
							"@request.auth.claims.Bla": {
								MatchType: &networking.StringMatch_Exact{
									Exact: "Bar",
								},
							},
						},
					},
				},
				Redirect: &networking.HTTPRedirect{