pass  # pragma: no cover


async def ws_dependency_validate(x_missing: str = Header()):
    pass  # pragma: no cover


@router.websocket("/depends-validate/")
async def router_ws_depends_validate(
    websocket: WebSocket, data=Depends(ws_dependency_validate)
):
    pass  # pragma: no cover


class CustomError(Exception):
    pass

     * @return HTML response for the edit form
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse edit(final EditForm form) {
        validate(form, messages -> {}, this::asListHtml);
        final String id = form.id;
        relatedContentService.getRelatedContent(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, op -> {});

     * @return HTML response for the web config edit form
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse edit(final EditForm form) {
        validate(form, messages -> {}, this::asListHtml);
        final String id = form.id;
        webConfigService.getWebConfig(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, copyOp -> {

package cmd

import (
	"context"
	"net/http"
	"strconv"
	"strings"

	"github.com/minio/minio/internal/logger"
	"github.com/minio/mux"

	"github.com/minio/pkg/v3/policy"
)

// Validate all the ListObjects query arguments, returns an APIErrorCode
// if one of the args do not meet the required conditions.
// Special conditions required by MinIO server are as below

	claims["exp"] = time.Now().UTC().Add(defaultExpiryDuration).Unix() // update with new expiry.
	return nil
}

const (
	audClaim = "aud"
	azpClaim = "azp"
)

// Validate - validates the id_token.
func (r *Config) Validate(ctx context.Context, arn arn.ARN, token, accessToken, dsecs string, claims map[string]any) error {
	jp := new(jwtgo.Parser)
	jp.ValidMethods = []string{
		"RS256", "RS384", "RS512",

			jwtgo.ValidationErrorClaimsInvalid)
	}

	// Signature is valid, lets validate the claims for
	// other fields such as expiry etc.
	return claims.Valid()
}

// ParseUnverifiedStandardClaims - WARNING: Don't use this method unless you know what you're doing
//
// This method parses the token but doesn't validate the signature. It's only
// ever useful in cases where you know the signature is valid (because it has

    }

    @Test
    @DisplayName("Methods should handle null buffer without validation")
    void testMethodsWithNullBuffer() {
        // The implementation doesn't validate null buffers
        // These methods simply return 0 without accessing the buffer

        // Write methods return 0 without accessing null buffer
        assertEquals(0, response.writeSetupWireFormat(null, 0));

     * Reloads the document index by closing and reopening it.
     *
     * @param form the action form (validated but not used for configuration)
     * @return HTML response redirecting to the maintenance page
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse reloadDocIndex(final ActionForm form) {
        validate(form, messages -> {}, this::asIndexHtml);
        verifyToken(this::asIndexHtml);

        "price": 42.0,
        "tax": 3.2
    },
    "user": {
        "username": "dave",
        "full_name": "Dave Grohl"
    },
    "importance": 5
}
```

Again, it will convert the data types, validate, document, etc.

## Multiple body params and query { #multiple-body-params-and-query }

Of course, you can also declare additional query parameters whenever you need, additional to any body parameters.

        return determineValid(value);
    }

    /**
     * Determines if the given value is a valid cron expression.
     * @param value the value to validate
     * @return true if valid, false otherwise
     */
    protected boolean determineValid(final String value) {
        if (StringUtil.isNotBlank(value) && !LaCronUtil.isCronExpValid(value)) {
            return false;