package okhttp3.logging.internal

import java.io.EOFException
import okio.Buffer

/**
 * Returns true if the body in question probably contains human readable text. Uses a small
 * sample of code points to detect unicode control characters commonly used in binary file
 * signatures.
 */
fun Buffer.isProbablyUtf8(): Boolean {
  try {
    val prefix = Buffer()
    val byteCount = size.coerceAtMost(64)
    copyTo(prefix, 0, byteCount)

	v := ActiveWorkerStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

        // Should read nothing (returns 0)
        assertEquals(0, read);
    }

    @Test
    void testReadDataWireFormat() {
        trans2QueryPathInfo = new Trans2QueryPathInformation(config, TEST_FILENAME, TEST_INFO_LEVEL);

        byte[] buffer = new byte[256];
        int read = trans2QueryPathInfo.readDataWireFormat(buffer, 0, buffer.length);

        try {
            return channel.read(buffer);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Reads the contents of the file channel into a byte buffer.
     *
     * @param channel
     *            The file channel. Must not be {@literal null}.
     * @param buffer

    void testReadSetupWireFormat() {
        netShareEnum = new NetShareEnum(realConfig);
        byte[] buffer = new byte[100];

        int result = netShareEnum.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);

        // Test with different parameters
        result = netShareEnum.readSetupWireFormat(buffer, 10, 50);
        assertEquals(0, result);

        // Test with zero length

	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

 *
 * <ul>
 *   <li>happy‑path behaviour</li>
 *   <li>boundary arguments (e.g., negative indices, large values)</li>
 *   <li>string representation containing the class name</li>
 *   <li>null buffer handling</li>
 * </ul>
 */
final class TransWaitNamedPipeResponseTest {

    /**
     * Verify that the default constructor creates an instance.
     */
    @Test
    void constructorInitialisesInstance() {

        byte[] buffer = new byte[4096];

        // When
        req.encode(buffer, 0);

        // Then
        byte[] pathBytes = longPath.getBytes(StandardCharsets.UTF_16LE);
        assertEquals(pathBytes.length, SMBUtil.readInt2(buffer, Smb2Constants.SMB2_HEADER_LENGTH + 6));
    }

    @Test
    @DisplayName("Should throw exception when buffer too small for path")

    int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        command = buffer[bufferIndex + CMD_OFFSET];
        errorCode = readInt4(buffer, bufferIndex + ERROR_CODE_OFFSET);
        flags = buffer[bufferIndex + FLAGS_OFFSET];
        flags2 = readInt2(buffer, bufferIndex + FLAGS_OFFSET + 1);
        tid = readInt2(buffer, bufferIndex + TID_OFFSET);
        pid = readInt2(buffer, bufferIndex + TID_OFFSET + 2);

        return 0;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        count = readInt2(buffer, bufferIndex) & 0xFFFFL;
        return 8;
    }

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

    @Override
    public String toString() {