OutputStream encodingStream = encoding.encoding.encodingStream(target);
      encodingStream.write(encodingInputs[i & INPUTS_MASK]);
      encodingStream.close();
      tmp += target.getBuffer().length();
    }
    return tmp;
  }

  @Benchmark
  public int decodingStream(int reps) throws IOException {
    int tmp = 0;
    byte[] target = new byte[n];
    for (int i = 0; i < reps; i++) {

            alignmentBytes = 1; // Need 1 byte of padding for 2-byte alignment
        }

        // The value 0xCD should be encoded as a 16-bit value (0x00CD) in little-endian
        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");

        boolean isDirect;
        DcerpcException de;

        if (state == 0) {
            bind();
        }

        isDirect = true;

        stub = jcifs.smb1.smb1.BufferCache.getBuffer();
        try {
            int off, tot, n;

            buf = new NdrBuffer(stub, 0);

            msg.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
            msg.call_id = call_id++;

                        // Test allocation performance
                        long allocStart = System.nanoTime();
                        byte[] buffer = BufferCache.getBuffer();
                        long allocEnd = System.nanoTime();
                        totalAllocTime.addAndGet(allocEnd - allocStart);
                        allocations.incrementAndGet();

    public int getTailSpace() {
        return buf.length - index;
    }

    /**
     * Returns the underlying byte buffer.
     *
     * @return the byte buffer
     */
    public byte[] getBuffer() {
        return buf;
    }

    /**
     * Aligns the buffer index to the specified boundary with a fill value.
     *
     * @param boundary the alignment boundary

            // In real implementation, this would receive using DiSNI:
            // RdmaCompletionEvent event = endpoint.getCqProcessor().getCqEvent(timeout);
            // if (event != null) {
            //     return event.getBuffer();
            // }
            // return null;

            // For skeleton implementation, return null (timeout)
            return null;

        } catch (Exception e) {

        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);

        // Setup buffer cache to return buffers for sendrecv operations
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks
     * Uses mock to avoid constructor issues while allowing real method calls
     */

    public int getTailSpace() {
        return this.buf.length - this.index;
    }

    /**
     * Returns the underlying byte buffer.
     *
     * @return the byte buffer
     */
    public byte[] getBuffer() {
        return this.buf;
    }

    /**
     * Aligns the buffer index to the specified boundary with a fill value.
     *
     * @param boundary the alignment boundary

    @BeforeEach
    void setUp() {
        // Setup buffer cache mocks with lenient stubbing
        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
        handle = new TestDcerpcHandle(mockContext, mockBinding);
    }

    @Nested
    @DisplayName("Binding Parsing Tests")
    class BindingParsingTests {

    void testGetTailSpace() {
        ndrBuffer.setIndex(100);
        assertEquals(buffer.length - 100, ndrBuffer.getTailSpace());
    }

    @Test
    void testGetBuffer() {
        assertSame(buffer, ndrBuffer.getBuffer());
    }

    @Test
    void testAlignWithValue() {
        // Align to 4-byte boundary with a fill value
        ndrBuffer.setIndex(1);
        int alignedBytes = ndrBuffer.align(4, (byte) 0xFF);