private class CountingSource(
    source: Source,
  ) : ForwardingSource(source) {
    var bytesRead = 0L

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      val result = delegate.read(sink, byteCount)
      if (result == -1L) return -1L
      bytesRead += result
      return result
    }
  }

            paramWordsRead = 10;
            return paramWordsRead;
        }

        @Override
        protected int readBytesWireFormat(byte[] src, int srcIndex) {
            bytesRead = 20;
            return bytesRead;
        }

        @Override
        public boolean isRetainPayload() {
            return retainPayload;
        }

        @Override
        public void setRawPayload(byte[] payload) {

        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);
        byte[] buffer = createTestData(256);

        // When
        int bytesRead = request.readBytesWireFormat(buffer, 0);

        // Then
        assertEquals(0, bytesRead);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100, 200 })
    @DisplayName("Should write consistent structure at different offsets")

            byte[] buffer = new byte[10];
            int bytesRead = in.read(buffer);
            assertEquals(10, bytesRead, "Should read requested bytes");
            assertEquals("0123456789", new String(buffer, 0, bytesRead, "UTF-8"));

            // Read next chunk
            bytesRead = in.read(buffer);
            assertEquals(10, bytesRead, "Should read next chunk");

        @Test
        @DisplayName("Should always return 0")
        void testReadBytesWireFormat() {
            byte[] buffer = new byte[100];

            int bytesRead = echoRequest.readBytesWireFormat(buffer, 0);

            assertEquals(0, bytesRead);
        }

        @Test
        @DisplayName("Should return 0 regardless of buffer content")
        void testReadBytesWithVariousBufferContent() {

        request = new Smb2SetInfoRequest(mockConfig);
        byte[] buffer = new byte[256];

        int bytesRead = request.readBytesWireFormat(buffer, 0);

        // This method should always return 0 as the request doesn't read responses
        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test complete flow with all setters")
    void testCompleteFlow() {

            when(mockConfig.isRequireSecureNegotiate()).thenReturn(false);

            // Read the response
            int bytesRead = echoResponse.readBytesWireFormat(buffer, bufferIndex);
            assertEquals(0, bytesRead);

            // Write response (echo responses don't write data)
            int bytesWritten = echoResponse.writeBytesWireFormat(buffer, 0);

    void testReadBytesWireFormatValid() throws Exception {
        // Given
        byte[] buffer = createValidNegotiateResponseBuffer();

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then
        assertTrue(bytesRead > 0);
        assertEquals(Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED, response.getSecurityMode());
        assertEquals(0x0311, response.getDialectRevision());

    void testReadBytesWireFormat() {
        request = new Smb2QueryDirectoryRequest(mockConfig);
        byte[] buffer = new byte[100];

        int bytesRead = request.readBytesWireFormat(buffer, 0);

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test size calculation with different buffer sizes")
    void testSizeCalculationWithDifferentBufferSizes() {

  }

  /**
   * We had a bug where self-finishing inflater streams would infinite loop!
   * https://github.com/square/okhttp/issues/8078
   */
  @Test fun `inflate returns finished before bytesRead reaches input length`() {
    val inflater = MessageInflater(false)
    val message = "53621260020000".decodeHex()
    assertThat(inflater.inflate(message)).isEqualTo("22021002".decodeHex())
  }