@Test
        @DisplayName("Should not modify buffer during write")
        void testWriteDoesNotModifyBuffer() {
            byte[] buffer = new byte[64];
            Arrays.fill(buffer, (byte) 0xAA);
            byte[] originalBuffer = buffer.clone();

            notification.writeBytesWireFormat(buffer, 0);

            assertArrayEquals(originalBuffer, buffer);
        }
    }

    @Nested

- Kubectl: Add `--use-protocol-buffers` flag to kubectl top pods and nodes. ([#96655](https://github.com/kubernetes/kubernetes/pull/96655), [@serathius](https://github.com/serathius))

                final int _buffers = _src.dec_ndr_long();
                _src.dec_ndr_long();
                final int _bufferl = _src.dec_ndr_long();
                final int _bufferi = _src.index;
                _src.advance(2 * _bufferl);

                if (buffer == null) {
                    if (_buffers < 0 || _buffers > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);

- `Scheduler` now registers event handlers dynamically. ([#101394](https://github.com/kubernetes/kubernetes/pull/101394), [@Huang-Wei](https://github.com/Huang-Wei))
- `kubectl`: Enable using protocol buffers to request Metrics API. ([#102039](https://github.com/kubernetes/kubernetes/pull/102039), [@serathius](https://github.com/serathius))

### Documentation

                _src = _src.deferred;
                final int _buffers = _src.dec_ndr_long();
                _src.dec_ndr_long();
                final int _bufferl = _src.dec_ndr_long();
                final int _bufferi = _src.index;
                _src.advance(2 * _bufferl);

                if (this.buffer == null) {
                    if (_buffers < 0 || _buffers > 0xFFFF) {

    assertThat(body.isOneShot()).isEqualTo(false)

    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)
    assertThat(buffer.readUtf8()).isEqualTo(expected)

    val buffer2 = Buffer()
    body.writeTo(buffer2)
    assertThat(body.contentLength()).isEqualTo(buffer2.size)
    assertThat(buffer2.readUtf8()).isEqualTo(expected)
  }

  @Test

        SMBUtil.writeInt2(8, buffer, 58); // Security buffer length

        // Add some dummy security data at offset 64 from start
        buffer[64] = (byte) 0x4E; // NTLMSSP signature start
        buffer[65] = (byte) 0x54;
        buffer[66] = (byte) 0x4C;
        buffer[67] = (byte) 0x4D;
        buffer[68] = (byte) 0x53;
        buffer[69] = (byte) 0x53;

- **Thread Safety**: Components support concurrent access
- **DFS Support**: Distributed File System resolution
- **Streaming Operations**: Efficient directory listings and file operations
- **Buffer Caching**: Optimized buffer management
- **DCE/RPC Protocol**: Support for advanced operations

## Quick Start

### Basic Usage

```java
import jcifs.CIFSContext;
import jcifs.context.SingletonContext;

 */
package okhttp3.internal.cache2

import java.io.IOException
import java.nio.channels.FileChannel
import okio.Buffer

/**
 * Read and write a target file. Unlike Okio's built-in `Okio.source(java.io.File file)` and `Okio.sink(java.io.File file)`
 * this class offers:
 *
 *  * **Read/write:** read and write using the same operator.
 *  * **Random access:** access any position within the file.

      val buffer = Buffer().writeString(this, charset)
      return buffer.asResponseBody(finalContentType, buffer.size)
    }

    /** Returns a new response body that transmits this byte array. */
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toResponseBody(contentType: MediaType? = null): ResponseBody =
      Buffer()
        .write(this)