SMBUtil.writeInt4(len, dst, dataLengthOffset);
                dstIndex += len;

                final int pad = pad8(dstIndex);
                totalCreateContextLength += len + pad;
                dstIndex += pad;
                lastStart = structStart;
            }
        }
        SMBUtil.writeInt4(totalCreateContextLength, dst, createContextLengthOffset);

        // Context handle (20 bytes) - this is both input and output (modified)
        if (contextHandle != null) {
            buf.writeOctetArray(contextHandle, 0, Math.min(contextHandle.length, 20));
            // Pad with zeros if context handle is shorter than 20 bytes
            for (int i = contextHandle.length; i < 20; i++) {
                buf.enc_ndr_small(0);
            }
        } else {

labels.file_crawling_configuration=Bestandscrawlen
labels.file_crawling_title_details=Bestandscrawlconfiguratie
labels.included_paths=Pad(en) om op te nemen in crawlen
labels.excluded_paths=Pad(en) om uit te sluiten van crawlen
labels.included_doc_paths=Pad(en) om op te nemen in zoeken
labels.excluded_doc_paths=Pad(en) om uit te sluiten van zoeken
labels.config_parameter=Configuratieparameter
labels.max_access_count=Maximaal aantal toegangspogingen

        final int length = string.length();
        if (length == 0) {
            return new byte[0];
        }
        final int pad = string.charAt(length - 2) == '=' ? 2 : string.charAt(length - 1) == '=' ? 1 : 0;
        final int size = length * 3 / 4 - pad;
        final byte[] buffer = new byte[size];
        int block;
        int i = 0;
        int index = 0;
        while (i < length) {

        assertArrayEquals(machineId, actualMachineId);
    }

    /**
     * Test with customData and machineId that are not exactly 8 and 32 bytes respectively.
     * The constructor requires exact sizes, so we need to pad them manually.
     */
    @Test
    void testAvSingleHostCustomDataMachineIdConstructor_ShorterInputs() {
        // Prepare padded arrays
        byte[] customData = new byte[8];
        customData[0] = 0x01;

    /**
     * This is an alternative to the <code>java.lang.Integer.toHexString</code>
     * method. It is an efficient relative that also will pad the left side so
     * that the result is <code>size</code> digits.
     *
     * @param val the integer value to convert to hexadecimal

   */
  protected void processRemaining(ByteBuffer bb) {
    Java8Compatibility.position(bb, bb.limit()); // move at the end
    Java8Compatibility.limit(bb, chunkSize + 7); // get ready to pad with longs
    while (bb.position() < chunkSize) {
      bb.putLong(0);
    }
    Java8Compatibility.limit(bb, chunkSize);
    Java8Compatibility.flip(bb);
    process(bb);
  }

  @Override

        int bodyStart = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        byte[] blob = new byte[] { 9, 8, 7, 6 };
        // Place blob further ahead to exercise pad adjustment logic
        int secBufOffset = Smb2Constants.SMB2_HEADER_LENGTH + 16; // beyond current bodyIndex (64+8)
        int sessionFlags = Smb2SessionSetupResponse.SMB2_SESSION_FLAGS_IS_NULL;

        buffer.putInt(entry1AlignedSize); // nextEntryOffset
        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        buffer.putInt(fileNameBytes1.length);
        buffer.put(fileNameBytes1);

        // Pad to aligned size
        while (buffer.position() < entry1AlignedSize) {
            buffer.put((byte) 0);
        }

        // Second notification
        buffer.putInt(entry2AlignedSize); // nextEntryOffset

	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetCenterSeparator("")
	table.SetColumnSeparator("")
	table.SetRowSeparator("")
	table.SetHeaderLine(false)
	// table.EnableBorder(false)
	table.SetTablePadding("\t") // pad with tabs
	table.SetNoWhiteSpace(true)

	if set {
		if err := setxattr(path, name, value); err != nil {
			log.Fatalln(fmt.Errorf("setting attribute %s failed with: %v", name, err))
		}
	} else {
		if name == "" {