// When
        boolean valid = response.isValid(mockContext, mockRequest);

        // Then
        assertTrue(valid);
        assertEquals(DialectVersion.SMB311, response.getSelectedDialect());
    }

    @Test
    @DisplayName("Should fail validation when not received")
    void testIsValidNotReceived() {
        // When
        boolean valid = response.isValid(mockContext, mockRequest);

    public void test_isUrlChar_extendedAscii() {
        // Test extended ASCII characters (not valid URL chars without encoding)
        assertFalse(CharUtil.isUrlChar('\u00A0')); // non-breaking space
        assertFalse(CharUtil.isUrlChar('\u00FF')); // ÿ
    }

    public void test_isUrlChar_unicode() {
        // Test Unicode characters (not valid URL chars without encoding)
        assertFalse(CharUtil.isUrlChar('\u3042')); // あ (Hiragana)

		default:
			apiErr = toAPIError(ctx, vErr)
		}
		valid = false
		return opts, valid
	}

	opts.MaxParts, err = parseIntHeader(bucket, object, r.Header, xhttp.AmzMaxParts)
	if err != nil {
		apiErr = toAPIError(ctx, err)
		argumentName = strings.ToLower(xhttp.AmzMaxParts)
		valid = false
		return opts, valid
	}

	if opts.MaxParts == 0 {
		opts.MaxParts = maxPartsList
	}

   * parsing fails. Always use this method in preference to {@link #fromValid(String)} for a
   * specifier that is not already known to be valid.
   *
   * @throws ParseException if the specifier is not valid.
   */
  @CanIgnoreReturnValue // TODO(b/219820829): consider removing
  public static HostSpecifier from(String specifier) throws ParseException {
    try {

func (c *StandardClaims) SetAccessKey(accessKey string) {
	c.Subject = accessKey
	c.AccessKey = accessKey
}

// Valid - implements https://godoc.org/github.com/golang-jwt/jwt#Claims compatible
// claims interface, additionally validates "accessKey" fields.
func (c *StandardClaims) Valid() error {
	if err := c.StandardClaims.Valid(); err != nil {
		return err
	}

	if c.AccessKey == "" && c.Subject == "" {

                    # but since the key is not valid, openapi.utils.get_openapi will raise ValueError
                    "hello": {"description": "Not a valid additional response"},
                    "200": {
                        "description": "Successful Response",
                        "content": {"application/json": {"schema": {}}},
                    },
                },

     */
    public void setValue(final String value) {
        this.value = value;
    }

    /**
     * Checks if the request header is valid.
     * A header is considered valid if its name is not blank and its value is not null.
     * @return true if the header is valid, false otherwise.
     */
    public boolean isValid() {
        if (StringUtil.isBlank(name) || value == null) {
            return false;
        }

func (n DeletedAt) Value() (driver.Value, error) {
	if !n.Valid {
		return nil, nil
	}
	return n.Time, nil
}

func (n DeletedAt) MarshalJSON() ([]byte, error) {
	if n.Valid {
		return json.Marshal(n.Time)
	}
	return json.Marshal(nil)
}

func (n *DeletedAt) UnmarshalJSON(b []byte) error {
	if string(b) == "null" {
		n.Valid = false
		return nil
	}
	err := json.Unmarshal(b, &n.Time)

	}
}

var ssecUnsealObjectKeyTests = []struct {
	Headers        http.Header
	Bucket, Object string
	Metadata       map[string]string

	ExpectedErr error
}{
	{ // 0 - Valid HTTP headers and valid metadata entries for bucket/object
		Headers: http.Header{
			"X-Amz-Server-Side-Encryption-Customer-Algorithm": []string{"AES256"},

		deletedAt     = mytime(time.Now())
		isAdmin       = mybool(false)
		user          = AdvancedDataTypeUser{
			ID:           sql.NullInt64{Int64: 10, Valid: true},
			Name:         &sql.NullString{String: name, Valid: true},
			Birthday:     sql.NullTime{Time: time.Now(), Valid: true},
			RegisteredAt: mytime(time.Now()),
			DeletedAt:    &deletedAt,
			Active:       mybool(true),
			Admin:        &isAdmin,
		}