this.maxFragmentedSize = RdmaCapabilities.DEFAULT_MAX_FRAGMENTED_SIZE;
    }

    /**
     * Decode from byte array
     *
     * @param data source data
     * @param offset starting offset
     * @return decoded response
     */
    public static SmbDirectNegotiateResponse decode(byte[] data, int offset) {
        if (data.length - offset < 32) {

            data.register("displayFileName", getJspFile(form.fileName, "view").getAbsolutePath());
        });
    }

    /**
     * Decode the JSP content.
     * @param value The value.
     * @return The decoded value.
     */
    public static String decodeJsp(final String value) {
        return value.replaceAll("<%(?![@-])([\\s\\S]*?)%>", "&lt;%$1%&gt;")

        objAttr.decode(mockNdrBuffer);

        assertEquals(100, objAttr.length);
        assertEquals(3, objAttr.attributes);
        assertEquals(4, objAttr.security_descriptor);

        verify(objAttr.root_directory).decode(mockDeferredNdrBuffer);
        verify(objAttr.object_name).decode(mockDeferredNdrBuffer);
        verify(objAttr.security_quality_of_service).decode(mockDeferredNdrBuffer);
    }

        @Test
        @DisplayName("Decode error handling should work correctly")
        void testDecodeErrorHandling() throws Exception {
            // Given
            when(mockHandle.getMaxXmit()).thenReturn(1024);
            when(mockHandle.getMaxRecv()).thenReturn(1024);
            DcerpcBind bindMessage = new DcerpcBind(mockBinding, mockHandle);

            // When - Decode with error response

              "00010000003b00049df00112"
          ).decodeHex(),
      )
    assertThat(decoded).containsExactly(InetAddress.getByName("157.240.1.18"))
  }

  @Test
  fun testGoogleDotComDecodingFromGoogleIPv6() {
    val decoded =
      decodeAnswers(
        hostname = "test.com",
        byteString =
          (

    /**
     * Creates a Kerberos AP request from a token.
     *
     * @param token the Kerberos AP-REQ token
     * @param keys the Kerberos keys for decryption
     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

        SMBUtil.writeInt8(expectedIndexNumber, buffer, bufferIndex);

        // Decode
        int bytesDecoded = fileInternalInfo.decode(buffer, bufferIndex, 8);

        // Verify
        assertEquals(8, bytesDecoded);
        assertEquals(expectedIndexNumber, fileInternalInfo.getIndexNumber());
    }

    @Test
    @DisplayName("Test decode with zero index number")

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify - the decode method strips null termination, so filename should match
        assertEquals(expectedFilename, fileBothDirectoryInfo.getFilename());
    }

    @Test
    @DisplayName("Test decode with null-terminated non-Unicode filename")

    }

    @Test
    @DisplayName("Test decode with minimum valid length")
    void testDecodeMinimumValidLength() throws SMBProtocolDecodingException {
        // Prepare minimum valid buffer - exactly 24 bytes
        byte[] buffer = new byte[28];
        Arrays.fill(buffer, 0, 24, (byte) 0xAA);

        // Decode with len = 24 (minimum valid)
        int bytesConsumed = response.decode(buffer, 0, 24);

            // Setup for SamrSamEntry decode chain
            mockDeferredBuffer.deferred = mockDeferredBuffer;
            when(mockDeferredBuffer.dec_ndr_short()).thenReturn(0, 0, 0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

            // Then: Should decode all output parameters
            verify(samArray).decode(mockNdrBuffer);