private val deflaterSink = DeflaterSink(deflatedBytes, deflater)

  /** Deflates [buffer] in place as described in RFC 7692 section 7.2.1. */
  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {

            return bytesWritten;
        }

        @Override
        int readParameterWordsWireFormat(byte[] buffer, int bufferIndex) {
            paramWordsRead = 10;
            return paramWordsRead;
        }

        @Override
        int readBytesWireFormat(byte[] buffer, int bufferIndex) {
            bytesRead = 20;
            return bytesRead;
        }

        // Test engineDigest with buffer too small
        HMACT64 hmac = new HMACT64(TEST_KEY);
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

        byte[] buffer = new byte[10];
        // Should throw exception when buffer is too small
        assertThrows(IllegalStateException.class, () -> hmac.engineDigest(buffer, 0, 10));
    }

    @Test
    void testClone() {

                if (!currentArg.isEmpty()) {
                    currentArg.setLength(currentArg.length() - 1);
                }

                cleaned.add(currentArg.toString());

                currentArg = null;
                continue;
            }

            // if we haven't added this arg to the buffer, and we ARE building an argument

    /**
     * Create new DiSNI memory region
     *
     * @param buffer memory buffer to register
     * @param access access permissions
     * @param endpoint DiSNI endpoint for registration
     */
    public DisniMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access, Object endpoint) {
        super(buffer, access);
        this.endpoint = endpoint;

        case MEMORY:
            return "Reduce buffer sizes or increase heap memory";
        case DISK_SPACE:
            return "Free up disk space or use a different location";
        case QUOTA:
            return "Contact administrator to increase quota limits";
        case LOCK:
            return "Release existing locks or wait for them to be released";
        case BUFFER:

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }

    }

    @Test
    @DisplayName("Test writeDataWireFormat with insufficient buffer")
    void testWriteDataWireFormatInsufficientBuffer() {
        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);
        byte[] dst = new byte[5]; // Buffer too small
        int dstIndex = 0;

        // Act

	 *     USHORT Length;
	 *     USHORT MaximumLength;
	 *     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT *  Buffer;
	 * } UNICODE_STRING;
	 */

	typedef struct {
		uint16_t length;
		uint16_t maximum_length;
		[length_is(length / 2),size_is(maximum_length / 2)] uint16_t *buffer;
	} unicode_string;

	/* 
	 * typedef struct _SID_IDENTIFIER_AUTHORITY {
	 *     UCHAR Value[6];

	 *     USHORT Length;
	 *     USHORT MaximumLength;
	 *     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT *  Buffer;
	 * } UNICODE_STRING;
	 */

	typedef struct {
		uint16_t length;
		uint16_t maximum_length;
		[length_is(length / 2),size_is(maximum_length / 2)] uint16_t *buffer;
	} unicode_string;

	/* 
	 * typedef struct _SID_IDENTIFIER_AUTHORITY {
	 *     UCHAR Value[6];