void testLongFileId() {
            byte[] longFileId = new byte[32];
            new SecureRandom().nextBytes(longFileId);
            request.setFileId(longFileId);
            request.setData(new byte[10], 0, 10);

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            // Should only copy first 16 bytes

			expectedCode:    304,
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			recorder := httptest.NewRecorder()
			request := httptest.NewRequest(http.MethodHead, "/bucket/a", bytes.NewReader([]byte{}))
			request.Header.Set(xhttp.IfNoneMatch, tc.ifNoneMatch)
			request.Header.Set(xhttp.IfModifiedSince, tc.ifModifiedSince)
			request.Header.Set(xhttp.IfMatch, tc.ifMatch)

            this.andxCommand = (byte) 0xFF;
            this.andx = null;

            dst[start + ANDX_COMMAND_OFFSET] = (byte) 0xFF;
            dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
            // dst[start + ANDX_OFFSET_OFFSET] = (byte)0x00;
            // dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;

     */
    static Stream<Arguments> decodeProvider() {
        return Stream.of(Arguments.of("", new byte[0]), Arguments.of("QQ==", new byte[] { (byte) 0x41 }), // "A"
                Arguments.of("QUI=", new byte[] { (byte) 0x41, (byte) 0x42 }), // "AB"
                Arguments.of("TWFu", "Man".getBytes()), Arguments.of("AAAA", new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00 }), // all zeros

        byte[] testSessionKey = new byte[16];
        Arrays.fill(testSessionKey, (byte) 0xAA);
        byte[] testPreauth = new byte[64];
        Arrays.fill(testPreauth, (byte) 0xBB);

        // When
        byte[] signingKey300 = Smb3KeyDerivation.deriveSigningKey(Smb2Constants.SMB2_DIALECT_0300, testSessionKey, testPreauth);

    private Pac pac;

    /**
     * Constructs KerberosPacAuthData from token bytes.
     *
     * @param token the PAC token bytes
     * @param keys map of Kerberos keys indexed by key type
     * @throws PACDecodingException if PAC decoding fails
     */
    public KerberosPacAuthData(byte[] token, Map<Integer, KerberosKey> keys) throws PACDecodingException {
        this.pac = new Pac(token, keys);
    }

     *
     * @param buffer buffer to read data into
     * @param remoteAddress remote memory address for RDMA read
     * @param remoteKey remote memory key
     * @param length number of bytes to read
     * @return number of bytes actually read
     * @throws IOException if read operation fails
     */
    public abstract int read(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException;

    /**

  public void testBytes() {
    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);

        assertEquals(16, guid2.toBytes().length);
    }

    @Test
    public void testHandleGuidRoundTrip() {
        HandleGuid original = new HandleGuid();
        byte[] bytes = original.toBytes();
        HandleGuid reconstructed = new HandleGuid(bytes);

        assertEquals(original, reconstructed);
        assertEquals(original.toString(), reconstructed.toString());

		"Total cluster raw storage capacity in bytes")
	healthCapacityRawFreeBytesMD = NewGaugeMD(healthCapacityRawFreeBytes,
		"Total cluster raw storage free in bytes")
	healthCapacityUsableTotalBytesMD = NewGaugeMD(healthCapacityUsableTotalBytes,
		"Total cluster usable storage capacity in bytes")
	healthCapacityUsableFreeBytesMD = NewGaugeMD(healthCapacityUsableFreeBytes,