}

func (b *wholeBitrotWriter) Write(p []byte) (int, error) {
	err := b.disk.AppendFile(context.TODO(), b.volume, b.filePath, p)
	if err != nil {
		return 0, err
	}
	_, err = b.Hash.Write(p)
	if err != nil {
		return 0, err
	}
	return len(p), nil
}

func (b *wholeBitrotWriter) Close() error {
	return nil
}

// Returns whole-file bitrot writer.

    /**
     * Write data to RDMA connection
     *
     * @param buffer buffer containing data to write
     * @param remoteAddress remote memory address for RDMA write
     * @param remoteKey remote memory key
     * @param length number of bytes to write
     * @return number of bytes actually written
     * @throws IOException if write operation fails
     */

 * and delete by query suggest items in an OpenSearch index.
 */
public class SuggestIndexWriter implements SuggestWriter {
    /**
     * Constructs a new {@link SuggestIndexWriter}.
     */
    public SuggestIndexWriter() {
        // nothing
    }

    @Override

     */
    public Smb2RdmaTransform getTransform() {
        return transform;
    }

    /**
     * Encode to byte array for SMB2 READ/WRITE channel info
     *
     * @param dst destination buffer
     * @param dstIndex starting index
     * @return number of bytes written
     */
    public int encode(byte[] dst, int dstIndex) {
        return transform.encode(dst, dstIndex);
    }

    @Override

      )

    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
      val requestBodyOut = requestBody.takeSink()
      assertFailsWith<IOException> {
        SlowRequestBody.writeTo(requestBodyOut)
      }
      assertFailsWith<IOException> {
        requestBodyOut.close()
      }
    }

    // Confirm that the connection pool was not corrupted by making another call.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.rdma;

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 RDMA Transform structure for READ/WRITE channel info.
 *
 * As per MS-SMB2 2.2.13.1.1 and 2.2.21.1.1
 */
public class Smb2RdmaTransform {

        // When
        int bytesWritten = trans.writeParametersWireFormat(dst, 0);

        // Then
        assertEquals(dst.length, bytesWritten, "The number of bytes written should match the expected length.");
        // Check informationLevel
        assertEquals((byte) (informationLevel & 0xFF), dst[0]);
        assertEquals((byte) ((informationLevel >> 8) & 0xFF), dst[1]);

     * @param outputBuffer the output buffer for decompressed data
     * @param outputOffset the offset in the output buffer
     * @param algorithm the compression algorithm that was used
     * @return the number of bytes written to the output buffer
     * @throws CIFSException if decompression fails
     */
    int decompress(byte[] compressedData, int offset, int length, byte[] outputBuffer, int outputOffset, int algorithm)

    val metadataBuffer = Buffer()
    metadataBuffer.write(metadata)

    val fileOperator = FileOperator(file!!.channel)
    fileOperator.write(FILE_HEADER_SIZE + upstreamSize, metadataBuffer, metadata.size.toLong())
  }

  @Throws(IOException::class)
  fun commit(upstreamSize: Long) {
    // Write metadata to the end of the file.
    writeMetadata(upstreamSize)
    file!!.channel.force(false)

        assertDoesNotThrow(() -> outputStream.write(data, 0, -1)); // negative length, returns early
        assertDoesNotThrow(() -> outputStream.write(data, 0, 0)); // zero length, returns early

        // These should pass through to the underlying implementation
        assertDoesNotThrow(() -> outputStream.write(data, 0, 10)); // valid - will consume first mock (10)