}

// Bytes provides a byte slice that can be serialized.
type Bytes []byte

// UnmarshalMsg deserializes b from the provided byte slice and returns the
// remainder of bytes.
func (b *Bytes) UnmarshalMsg(bytes []byte) ([]byte, error) {
	if b == nil {
		return bytes, errors.New("Bytes: UnmarshalMsg on nil pointer")
	}
	if bytes, err := msgp.ReadNilBytes(bytes); err == nil {
		if *b != nil {
			PutByteBuffer(*b)

        byte[] buffer = new byte[bufferSize];

        // Path consumed (2 bytes) - value: 10 * 2 = 20
        SMBUtil.writeInt2(20, buffer, 0);

        // Number of referrals (2 bytes) - value: 1
        SMBUtil.writeInt2(1, buffer, 2);

        // Flags (2 bytes)
        SMBUtil.writeInt2(0x0003, buffer, 4);

        // Padding (2 bytes)
        buffer[6] = 0;

		t.Fatal(err)
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}
	b := buf.Bytes()

	var sig [4]byte
	binary.LittleEndian.PutUint32(sig[:], uint32(fileHeaderSignature))

	idx := bytes.Index(b, sig[:])
	if idx == -1 {
		t.Fatal("file header not found")
	}
	b = b[idx:]

	if !bytes.Equal(b[6:10], []byte{0, 0, 0, 0}) { // FileHeader.Flags: 0, FileHeader.Method: 0

            // For CCM cipher, pad nonce to 16 bytes with zeros
            System.arraycopy(nonce, 0, this.nonce, 0, 12);
            // Last 4 bytes remain zero-initialized
        } else if (nonce.length == 16) {
            // For GCM cipher, use full 16-byte nonce
            System.arraycopy(nonce, 0, this.nonce, 0, 16);
        } else {
            throw new IllegalArgumentException("Nonce must be 12 bytes (CCM) or 16 bytes (GCM)");
        }

        // Compare the bytes. Note that the file stores UTF-8 encoded bytes, so we must compare the
        // unsigned bytes.
        var compareResult: Int
        var currentLabelIndex = labelIndex
        var currentLabelByteIndex = 0
        var publicSuffixByteIndex = 0

        var expectDot = false
        while (true) {
          val byte0: Int
          if (expectDot) {

    }

    private byte[] prepareAllocationInfoBuffer() {
        byte[] buffer = new byte[100];
        int offset = 0;

        // idFileSystem (4 bytes)
        SMBUtil.writeInt4(0, buffer, offset);
        offset += 4;

        // sectPerAlloc (4 bytes)
        SMBUtil.writeInt4(8, buffer, offset);
        offset += 4;

        // alloc (4 bytes)

        // Signature (8 bytes)
        for (int i = 14; i < 22; i++) {
            buffer[i] = 0x00;
        }

        // Reserved (2 bytes)
        buffer[22] = 0x00;
        buffer[23] = 0x00;

        // TID (2 bytes)
        buffer[24] = 0x01;
        buffer[25] = 0x00;

        // PID (2 bytes)
        buffer[26] = 0x02;
        buffer[27] = 0x00;

        // UID (2 bytes)
        buffer[28] = 0x03;

     *
     * @param str the string to encode
     * @return the string as bytes (UTF16-LE)
     */
    public static byte[] getUNIBytes(final String str) {
        return getBytes(str, UNI_ENCODING);
    }

    /**
     * Encodes a string into ASCII bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (ASCII)
     */

    /** Total number of parameter bytes the server is returning */
    protected int totalParameterCount;
    /** Total number of data bytes the server is returning */
    protected int totalDataCount;
    /** Number of parameter bytes in this response */
    protected int parameterCount;
    /** Offset from the start of the SMB header to the parameter bytes */
    protected int parameterOffset;

     * The constructor should only use the first 8/32 bytes.
     */
    @Test
    void testAvSingleHostCustomDataMachineIdConstructor_LongerInputs() {
        byte[] customData = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A }; // Longer than 8
        byte[] machineId = new byte[40]; // Longer than 32
        for (int i = 0; i < 40; i++) {
            machineId[i] = (byte) i;
        }