assertEquals(smbComNtTransaction.parameterOffset, SmbComTransaction.readInt4(dst, 23),
                "parameterOffset should be written correctly");
        assertEquals(smbComNtTransaction.dataCount, SmbComTransaction.readInt4(dst, 27), "dataCount should be written correctly");
        assertEquals(smbComNtTransaction.dataOffset, SmbComTransaction.readInt4(dst, 31), "dataOffset should be written correctly");

		return
	}
	err = en.WriteInt(z.pool)
	if err != nil {
		err = msgp.WrapError(err, "pool")
		return
	}
	// write "set"
	err = en.Append(0xa3, 0x73, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.set)
	if err != nil {
		err = msgp.WrapError(err, "set")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten, "Should write 4 bytes");
        // Check that structure size (4) is written as 2-byte little-endian
        assertEquals(4, buffer[offset] | (buffer[offset + 1] << 8), "Structure size should be 4");
        assertEquals(0, buffer[offset + 2], "Reserved bytes should be 0");

    void testWriteSetupWireFormat() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", 0x16, 10, 1024);

        byte[] buffer = new byte[10];
        int written = trans2FindFirst2.writeSetupWireFormat(buffer, 0);

        assertEquals(2, written);
        assertEquals((byte) Trans2FindFirst2.TRANS2_FIND_FIRST2, buffer[0]);
        assertEquals((byte) 0x00, buffer[1]);
    }

    @Test

   * {@code Writer}. When the returned {@code OutputStream} is closed, so is the backing {@code
   * Writer}.
   */
  @J2ktIncompatible
  @GwtIncompatible // Writer,OutputStream
  public abstract OutputStream encodingStream(Writer writer);

  /**
   * Returns a {@code ByteSink} that writes base-encoded bytes to the specified {@code CharSink}.
   */
  @J2ktIncompatible

        assertEquals(0x00, buffer[4]);
        assertEquals(0x00, buffer[5]);

        // Check that filename is written correctly (starting at offset 6)
        // The filename should be null-terminated Unicode string
        assertTrue(written > 6);

        // Verify the total bytes written is reasonable
        assertTrue(written > TEST_FILENAME.length());
    }

    @ParameterizedTest

	}

	if len(buffer) > int(fi.Erasure.BlockSize) {
		buffer = buffer[:fi.Erasure.BlockSize]
	}
	writers := make([]io.Writer, len(onlineDisks))
	for i, disk := range onlineDisks {
		if disk == nil {
			continue
		}
		writers[i] = newBitrotWriter(disk, bucket, minioMetaTmpBucket, tmpPartPath, erasure.ShardFileSize(data.Size()), DefaultBitrotAlgorithm, erasure.ShardSize())
	}

   *     {@link ByteOrder#LITTLE_ENDIAN}, to which a BYTES-long byte representation of this instance
   *     is written. In the process increases the position of {@link ByteBuffer} by BYTES.
   */
  void writeTo(ByteBuffer buffer) {
    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,
        "Expected at least Stats.BYTES = %s remaining , got %s",

            bufferIndex += bc;
        }
        return bufferIndex - start;
    }

    /**
     * Writes the SMB2 header to the wire format.
     *
     * @param dst the destination buffer
     * @param dstIndex the starting position in the buffer
     * @return number of bytes written
     */
    protected int writeHeaderWireFormat(final byte[] dst, final int dstIndex) {

	if err != nil {
		err = msgp.WrapError(err, "ForwardTo")
		return
	}
	// write "Limit"
	err = en.Append(0xa5, 0x4c, 0x69, 0x6d, 0x69, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Limit)
	if err != nil {
		err = msgp.WrapError(err, "Limit")
		return
	}
	// write "DiskID"
	err = en.Append(0xa6, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x44)
	if err != nil {
		return
	}