void testReadParameterWordsWireFormat() {
        byte[] buffer = new byte[1024];

        int result = setupAndX.readParameterWordsWireFormat(buffer, 0);

        // The implementation always returns 0
        assertEquals(0, result, "readParameterWordsWireFormat returns 0");
    }

    @Test
    void testReadBytesWireFormat() {
        byte[] buffer = new byte[1024];

  public static <E> int drain(
      BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout)
      throws InterruptedException {
    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
    return drain(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
  }

  /**

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

                        assertNotNull(buffer, "Buffer should not be null");
                        assertTrue(buffer.length > 0, "Buffer should have positive length");

    public void transferInitiated(TransferEvent transferEvent) {
        listener.transferInitiated(wrap(transferEvent));
    }

    @Override
    public void transferProgress(TransferEvent transferEvent, byte[] buffer, int length) {
        Long transferred;
        synchronized (transfers) {
            transferred = transfers.get(transferEvent.getResource());
            if (transferred == null) {

        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

     * @param buffer the source byte array
     * @param bufferIndex the starting index in the source array
     * @return the time value in milliseconds since January 1, 1970 UTC
     */
    public static long readUTime(final byte[] buffer, final int bufferIndex) {
        return (readInt4(buffer, bufferIndex) & 0xFFFFFFFFL) * 1000L;
    }

    /**

        return 0;
    }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        if (pipe.pipeIn != null) {

    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);

        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        final int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();

//      serialized representation of a `RunOptions` protocol buffer.
//    - `run_metadata` may be NULL, in which case it will be ignored; or
//      non-NULL, in which case it must point to an empty, freshly allocated
//      `TF_Buffer` that may be updated to contain the serialized representation
//      of a `RunMetadata` protocol buffer.
//
// The caller retains ownership of `input_values` (which can be deleted using

            verify(mockNdrBuffer).enc_ndr_short((short) 6);
            verify(mockNdrBuffer).enc_ndr_referent(entry.name.buffer, 1);
        }

        @Test
        @DisplayName("Should encode entry with null buffer")
        void testEncodeNullBuffer() throws NdrException {
            // Given: SAM entry with null buffer
            samr.SamrSamEntry entry = new samr.SamrSamEntry();
            entry.idx = 1;