setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

        // Write notification data at buffer offset 80

	const maxNanoSecondDigits = 9

	// Split string into seconds and sub-seconds parts.
	ss, sn, _ := strings.Cut(s, ".")

	// Parse the seconds.
	secs, err := strconv.ParseInt(ss, 10, 64)
	if err != nil {
		return time.Time{}, ErrHeader
	}
	if len(sn) == 0 {
		return time.Unix(secs, 0), nil // No sub-second values
	}

	// Parse the nanoseconds.

				schema.err = fmt.Errorf("invalid serializer type %v", serializerName)
			}
		}
	}

	if num, ok := field.TagSettings["AUTOINCREMENTINCREMENT"]; ok {
		field.AutoIncrementIncrement, _ = strconv.ParseInt(num, 10, 64)
	}

	if v, ok := field.TagSettings["DEFAULT"]; ok {
		field.HasDefaultValue = true
		field.DefaultValue = v
	}

	if num, ok := field.TagSettings["SIZE"]; ok {

 * attributes for business methods.
 * <p>
 * For example:
 *
 * <pre>
 * &#064;Secured({ &quot;ROLE_USER&quot; })
 * public void create(Contact contact);
 *
 * &#064;Secured({ &quot;ROLE_USER&quot;, &quot;ROLE_ADMIN&quot; })
 * public void update(Contact contact);
 *
 * &#064;Secured({ &quot;ROLE_ADMIN&quot; })
 * public void delete(Contact contact);
 * </pre>
 */

	if len(offsetBeginString) > 0 {
		if offsetBeginString[0] == '+' {
			return nil, fmt.Errorf("Byte position ('%s') must not have a sign", offsetBeginString)
		} else if offsetBegin, err = strconv.ParseInt(offsetBeginString, 10, 64); err != nil {
			return nil, fmt.Errorf("'%s' does not have a valid first byte position value", rangeString)
		} else if offsetBegin < 0 {
			return nil, fmt.Errorf("First byte position is negative ('%d')", offsetBegin)
		}

    }
  }

  /** No SNI for literal IPv6 addresses. */
  @Test
  fun ipv6() {
    val recordedRequest = requestToHostnameViaProxy("2607:f8b0:400b:804::200e")
    assertThat(recordedRequest.url.host).isEqualTo("2607:f8b0:400b:804::200e")
    assertThat(recordedRequest.handshakeServerNames).isEmpty()
  }

  /** No SNI for literal IPv4 addresses. */
  @Test
  fun ipv4() {

	}

	cred, _, s3Err := checkKeyValid(r, accessKey)
	if s3Err != ErrNone {
		return s3Err
	}

	// Make sure the request has not expired.
	expiresInt, err := strconv.ParseInt(expires, 10, 64)
	if err != nil {
		return ErrMalformedExpires
	}

	// Check if the presigned URL has expired.
	if expiresInt < UTCNow().Unix() {
		return ErrExpiredPresignRequest
	}

	}
	volume := r.Form.Get(storageRESTVolume)
	filePath := r.Form.Get(storageRESTFilePath)
	offset, err := strconv.ParseInt(r.Form.Get(storageRESTOffset), 10, 64)
	if err != nil {
		s.writeErrorResponse(w, err)
		return
	}
	length, err := strconv.ParseInt(r.Form.Get(storageRESTLength), 10, 64)
	if err != nil {
		s.writeErrorResponse(w, err)
		return
	}

            // closing should null tmp; subsequent readDirect should fail
            in.close();
            IOException ex = assertThrows(IOException.class, () -> in.readDirect(new byte[8], 0, 4));
            assertTrue(ex.getMessage().contains("Bad file descriptor"));
        }

        @Test
        @DisplayName("available always returns 0")
        void availableAlwaysZero() throws Exception {

    // Helper: build a minimal SMB2 header with a given status
    private static byte[] buildHeader(int status) {
        byte[] hdr = new byte[64]; // SMB2 header is 64 bytes
        System.arraycopy(SMBUtil.SMB2_HEADER, 0, hdr, 0, 64);
        // Write Status (little-endian) at offset 8 in the SMB2 header
        SMBUtil.writeInt4(status, hdr, 8);
        // Write Command = SMB2_IOCTL (0x000B) at offset 12
        SMBUtil.writeInt2(0x000B, hdr, 12);