@Override
    public byte[] compress(byte[] data, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        return compress(data, 0, data.length, algorithm);
    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {

    }

    @Test
    @DisplayName("Test update method with valid data")
    void testUpdateWithValidData() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };

        assertDoesNotThrow(() -> digest.update(data, 0, data.length));
    }

    @Test
    @DisplayName("Test update method with zero length")

 * into a ResultData object, and for retrieving the binary data from an AccessResultData object.
 * It extends the AbstractTransformer class.
 *
 * <p>
 * This transformer extracts the binary content from the response body of a web resource,
 * stores it as a byte array in the ResultData, and provides a method to retrieve this data
 * as a ByteArrayInputStream.
 * </p>
 *

    protected int dataOffset;
    /** Displacement of these data bytes from the start of the total data block */
    protected int dataDisplacement;
    /** Number of setup words in this response */
    protected int setupCount;
    /** Start position of parameter data in the buffer */
    protected int bufParameterStart;
    /** Start position of data bytes in the buffer */

        int type2 = AvPair.MsvAvEOL;
        byte[] raw2 = new byte[] {};
        AvPair avPair2 = new AvPair(type2, raw2);

        assertEquals(type2, avPair2.getType(), "Type should match the constructor argument for empty raw data.");
        assertArrayEquals(raw2, avPair2.getRaw(), "Raw data should match the constructor argument for empty raw data.");

        // Test with null raw data
        int type3 = AvPair.MsvAvFlags;

        // Test with a basic byte array
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };

    }
  }

  fun toX509Certificate(): X509Certificate {
    val data = CertificateAdapters.certificate.toDer(this)
    try {
      val certificateFactory = CertificateFactory.getInstance("X.509")
      val certificates = certificateFactory.generateCertificates(Buffer().write(data).inputStream())
      return certificates.single() as X509Certificate
    } catch (e: NoSuchElementException) {

	}

	for i, testCase := range testCases {
		data, err := xml.Marshal(testCase.name)
		expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {

        data.setMethod(Method.POST);
        assertEquals(Method.POST, data.getMethod());

        data.setMethod(Method.HEAD);
        assertEquals(Method.HEAD, data.getMethod());
    }

    public void test_methodStringSetterGet() {
        // Test String-based method setter with GET
        RequestData data = new RequestData();
        data.setMethod(Constants.GET_METHOD);

     * - Phase-specific data
     */
    REQUEST_SCOPED,

    /**
     * Caching should be disabled for this data.
     * Suitable for:
     * - Sensitive information
     * - Non-deterministic operations
     * - Debug or development data
     */
    DISABLED