}

    @Test
    @DisplayName("releaseBuffer should accept byte arrays gracefully")
    void testReleaseBufferContract() {
        // Given
        byte[] buffer = new byte[1024];
        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then
        assertDoesNotThrow(() -> {
            mockBufferCache.releaseBuffer(buffer);
        }, "releaseBuffer should handle valid buffers");
    }

                }
            }
            return new byte[this.bufferSize];
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.BufferCache#releaseBuffer(byte[])
     */
    @Override
    public void releaseBuffer(final byte[] buf) {
        if (buf == null) {
            return;
        }
        // better safe than sorry: prevent leaks if there is some out of bound access

        byte[] a = new byte[1];
        byte[] c = new byte[2];
        byte[] d = new byte[4];

        impl.releaseBuffer(a); // goes to slot 0
        impl.releaseBuffer(c); // goes to slot 1
        impl.releaseBuffer(d); // dropped (cache full)

        byte[] first = impl.getBuffer(); // should return slot 0 -> a
        byte[] second = impl.getBuffer(); // then slot 1 -> c

     */
    byte[] getBuffer();

    /**
     * Return a buffer to the cache
     *
     * @param buf the buffer to return to the cache for reuse
     */
    void releaseBuffer(byte[] buf);

        // When/Then - Should handle invalid buffers gracefully
        assertDoesNotThrow(() -> {
            BufferCache.releaseBuffer(nullBuffer); // Should ignore null
            BufferCache.releaseBuffer(wrongSizeBuffer); // Should ignore wrong size
            BufferCache.releaseBuffer(correctBuffer); // Should accept correct size
        });
    }

    /**

                msgBuf = new NdrBuffer(inB, 0);
            }
            msg.decode(msgBuf);
        } finally {
            this.transportContext.getBufferCache().releaseBuffer(inB);
            this.transportContext.getBufferCache().releaseBuffer(out);
        }

        DcerpcException de = msg.getResult();
        if (de != null) {
            throw de;
        }
    }

    /**
     * @param msg

    /**
     * Returns a buffer to the cache for reuse.
     *
     * Performance: O(1) operation with size limit check
     *
     * @param buf the buffer to return to the cache
     */
    static public void releaseBuffer(final byte[] buf) {
        // Validate buffer before returning to cache
        if (buf == null || buf.length != SmbComTransaction.TRANSACTION_BUF_SIZE) {
            return; // Silently ignore invalid buffers
        }

                this.response_map.remove(k);
                getContext().getBufferCache().releaseBuffer(resp.releaseBuffer());
            }
        } catch (final InterruptedException ie) {
            throw new TransportException(ie);
        } finally {
            getContext().getBufferCache().releaseBuffer(req.releaseBuffer());
        }

    }

    @Override
    public String toString() {

     *
     * For direct buffers, we rely on GC. A more sophisticated
     * implementation could maintain a buffer pool here as well.
     *
     * @param buffer buffer to release
     */
    public void releaseBuffer(ByteBuffer buffer) {
        // For direct buffers, we rely on GC
        // Could implement a more sophisticated buffer pool here
    }

    /**
     * Clean up all pooled regions
     *

    public void setBuffer(final byte[] buffer) {
        this.txn_buf = buffer;
    }

    /**
     * Releases and returns the transaction buffer
     * @return the txn_buf
     */
    public byte[] releaseBuffer() {
        final byte[] buf = this.txn_buf;
        this.txn_buf = null;
        return buf;
    }

    /**
     * Gets the transaction subcommand
     * @return the subCommand
     */