* @param length length of data to send
     * @throws IOException if an I/O error occurs
     */
    void send(byte[] buf, int off, int length) throws IOException;

    /**
     * Performs a transaction on the pipe.
     *
     * @param buf the buffer containing the transaction data
     * @param off the offset in the buffer
     * @param length the length of data to send

	v := BatchJobReplicateCredentials{}
	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 BenchmarkDecodeBatchJobReplicateCredentials(b *testing.B) {
	v := BatchJobReplicateCredentials{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

import java.nio.Buffer;

/**
 * Wrappers around {@link Buffer} methods that are covariantly overridden in Java 9+. See
 * https://github.com/google/guava/issues/3990
 */
@GwtIncompatible
final class Java8Compatibility {
  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

  static void limit(Buffer b, int limit) {
    b.limit(limit);
  }

    }

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

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

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) throws SMBProtocolDecodingException {

            assertEquals(8192L, SMBUtil.readInt8(buffer, 8)); // Offset
            assertArrayEquals(testFileId, Arrays.copyOfRange(buffer, 16, 32)); // File ID
            assertEquals(512, SMBUtil.readInt4(buffer, 32)); // Minimum count
            assertEquals(Smb2ReadRequest.SMB2_CHANNEL_NONE, SMBUtil.readInt4(buffer, 36)); // Channel
            assertEquals(1024, SMBUtil.readInt4(buffer, 40)); // Remaining bytes

 * limitations under the License.
 */
package okhttp3

import java.io.IOException
import okhttp3.Interceptor.Chain
import okio.Buffer
import okio.BufferedSink
import okio.ForwardingSink
import okio.Sink
import okio.buffer

/** Rewrites the request body sent to the server to be all uppercase.  */
class UppercaseRequestInterceptor : Interceptor {
  @Throws(IOException::class)

        SmbComWriteAndXResponse response = new SmbComWriteAndXResponse();
        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.

        }
        this.setNumEntries(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.isEndOfSearch = ((buffer[bufferIndex] & 0x01) == 0x01) == true;
        bufferIndex += 2;
        this.eaErrorOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.lastNameOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        return bufferIndex - start;
    }

        int value = 0x12345678;
        byte[] buffer = new byte[4];

        // When - encode little endian
        Encdec.enc_uint32le(value, buffer, 0);
        long decoded = Encdec.dec_uint32le(buffer, 0);

        // Then
        assertEquals(value & 0xFFFFFFFFL, decoded);
        assertEquals(0x78, buffer[0] & 0xFF);
        assertEquals(0x56, buffer[1] & 0xFF);
        assertEquals(0x34, buffer[2] & 0xFF);

    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;
        this.isLoggedInAsGuest = ((buffer[bufferIndex] & 0x01) == 0x01) == true;
        bufferIndex += 2;
        if (this.isExtendedSecurity()) {
            final int blobLength = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            this.blob = new byte[blobLength];