import okhttp3.internal.writeMedium
import okio.Buffer
import okio.BufferedSink

/** Writes HTTP/2 transport frames. */
@Suppress("NAME_SHADOWING")
class Http2Writer(
  private val sink: BufferedSink,
  private val client: Boolean,
) : Closeable,
  Lockable {
  private val hpackBuffer: Buffer = Buffer()
  private var maxFrameSize: Int = INITIAL_MAX_FRAME_SIZE

        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() {

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

  @Test
  fun buildEmptyForm() {
    val body = FormBody.Builder().build()
    val expected = ""
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(buffer.readUtf8()).isEqualTo(expected)

        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);

		t.Fatal(err)
	}
	if hdr.Name != longName {
		t.Fatal("Couldn't recover long name")
	}
}

func TestValidTypeflagWithPAXHeader(t *testing.T) {
	var buffer bytes.Buffer
	tw := NewWriter(&buffer)

	fileName := strings.Repeat("ab", 100)

	hdr := &Header{
		Name:     fileName,
		Size:     4,
		Typeflag: 0,
	}
	if err := tw.WriteHeader(hdr); err != nil {

     *
     * @param buffer source buffer
     * @param bufferIndex starting index
     * @return decoded transform
     */
    public static Smb2RdmaTransform decode(byte[] buffer, int bufferIndex) {
        long offset = SMBUtil.readInt8(buffer, bufferIndex);
        int token = SMBUtil.readInt4(buffer, bufferIndex + 8);
        int length = SMBUtil.readInt4(buffer, bufferIndex + 12);

		return nil, errors.New("config: encryption metadata is too large")
	}
	header[0] = Version
	binary.LittleEndian.PutUint32(header[1:], uint32(len(metadata)))
	buffer.Write(header[:])
	buffer.Write(metadata)

	return io.MultiReader(
		&buffer,
		stream.EncryptReader(plaintext, nonce, nil),
	), nil
}

// Decrypt decrypts the ciphertext using a key managed by the KMS.

        }
        SMBUtil.writeInt4(flags, buffer, offset);
        offset += 4;

        // NotificationFilter (4 bytes)
        SMBUtil.writeInt4(notificationFilter, buffer, offset);
        offset += 4;

        return offset - start;
    }

    /**
     * Decode directory lease context from buffer
     *
     * @param buffer the buffer containing the context data

        // Max write size
        SMBUtil.writeInt4(1048576, buffer, offset + 36);

        // System time
        SMBUtil.writeTime(System.currentTimeMillis(), buffer, offset + 40);

        // Server start time
        SMBUtil.writeTime(System.currentTimeMillis() - 3600000, buffer, offset + 48);

        // Security buffer offset and length
        SMBUtil.writeInt2(128, buffer, offset + 56); // Offset

/**
 * Interface for objects that can be decoded from a byte buffer.
 * This interface provides methods for deserializing data from SMB protocol messages.
 *
 * @author mbechler
 */
public interface Decodable {

    /**
     * Decode data from a byte buffer
     *
     * @param buffer the byte buffer containing the data to decode
     * @param bufferIndex the starting index in the buffer
     * @param len the maximum length of data to decode