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

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }

    T pivotValue = uncheckedCastNullableTToT(buffer[pivotIndex]);
    buffer[pivotIndex] = buffer[right];

    int pivotNewIndex = left;
    for (int i = left; i < right; i++) {
      if (comparator.compare(uncheckedCastNullableTToT(buffer[i]), pivotValue) < 0) {
        swap(pivotNewIndex, i);
        pivotNewIndex++;
      }
    }
    buffer[right] = buffer[pivotNewIndex];
    buffer[pivotNewIndex] = pivotValue;

                new TestNetbiosName("WORKSTATION1", 0x00, "CORP.LOCAL"));

        // Write to buffer
        byte[] buffer = new byte[512];
        int written = originalPacket.writeWireFormat(buffer, 0);

        // Read from buffer
        ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
        SessionRequestPacket readPacket = new SessionRequestPacket(mockConfig);

        return 0;
    }

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

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

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

    @Override