byte[] buffer = new byte[6];
        close.writeParameterWordsWireFormat(buffer, 0);
        // first two bytes encode fid 42
        assertEquals((byte) 42, buffer[0]);
        assertEquals((byte) 0, buffer[1]);
        // remaining 4 bytes should all be 0xFF according to writeUTime
        for (int i = 2; i < 6; i++) {
            assertEquals((byte) 0xFF, buffer[i], "byte %d should be 0xFF".formatted(i));

import kotlin.test.Test
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.ResponseBody.Companion.toResponseBody
import okio.Buffer
import okio.BufferedSource
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8
import okio.IOException
import okio.Source
import okio.buffer

class ResponseBodyTest {
  @Test
  fun sourceEmpty() {

            logger.info("");

            MessageBuilder buffer = builder().strong(">>> ");
            append(buffer, event.getMojoExecution());
            buffer.strong(" > ");
            appendForkInfo(buffer, event.getMojoExecution().getMojoDescriptor());
            append(buffer, event.getProject());
            buffer.strong(" >>>");

            logger.info(buffer.toString());
        }
    }

      derWriter.writeUtf8("a".repeat(201))
    }

    assertThat(buffer.readByteString(3)).isEqualTo("1e81c9".decodeHex())
    assertThat(buffer.readUtf8()).isEqualTo("a".repeat(201))
  }

  @Test fun `decode primitive bit string`() {
    val buffer =
      Buffer()
        .write("0307040A3B5F291CD0".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

                SmbComReadAndX readCmd = invocation.getArgument(0);
                SmbComReadAndXResponse response = invocation.getArgument(1);
                response.dataLength = 1;
                // The response buffer points to the internal tmp buffer
                if (response.b != null && response.off < response.b.length) {
                    response.b[response.off] = 42; // Return byte value 42
                }
                return null;

            assertEquals(0, smbComTreeDisconnect.readBytesWireFormat(buffer, i));
        }
    }

    /**
     * Test boundary conditions for buffer indices
     */
    @Test
    @DisplayName("Test boundary conditions for buffer indices")
    public void testBoundaryConditions() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.namedPipeState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.readDataAvailable = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.numberOfMessages = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

     * Test for the readSetupWireFormat method.
     * It should always return 0.
     */
    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];
        // The method should not read anything and return 0
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 10), "readSetupWireFormat should return 0.");
    }

    /**
     * Test for the readParametersWireFormat method.
     * It should always return 0.

      )
    return CertificateAdapters.subjectPublicKeyInfo.toDer(subjectPublicKeyInfo)
  }

  /** Returns a byte string that differs from this one by one bit. */
  private fun ByteString.offByOneBit(): ByteString =
    Buffer()
      .write(this, 0, size - 1)
      .writeByte(this[size - 1].toInt() xor 1)
      .readByteString()

  private fun date(s: String): Date =

    ByteBuffer buffer;

    ByteBufferHasher(int expectedInputSize) {
      this.buffer = ByteBuffer.allocate(expectedInputSize).order(ByteOrder.LITTLE_ENDIAN);
    }

    /**
     * Resizes the buffer if necessary. Guaranteed to leave `buffer` in Write Mode ready for new
     * data.
     */
    private void ensureCapacity(int needed) {
      if (buffer.remaining() >= needed) {
        return;
      }