+ parameterCount + ",parameterOffset=" + parameterOffset + ",parameterDisplacement=" + parameterDisplacement + ",dataCount="
                + dataCount + ",dataOffset=" + dataOffset + ",dataDisplacement=" + dataDisplacement + ",setupCount=" + setupCount + ",pad="
                + pad + ",pad1=" + pad1);
    }

            dataOffset += pad1;

            dataDisplacement += dataCount;

            available -= pad1;
            dataCount = Math.min(totalDataCount - dataDisplacement, available);
        }
        if (parameterDisplacement + parameterCount >= totalParameterCount && dataDisplacement + dataCount >= totalDataCount) {
            hasMore = false;
        }
        return this;

                + this.parameterDisplacement + ",dataCount=" + this.dataCount + ",dataOffset=" + this.dataOffset + ",dataDisplacement="
                + this.dataDisplacement + ",setupCount=" + this.setupCount + ",pad=" + this.pad + ",pad1=" + this.pad1);
    }

        // dataCount = 15
        writeInt4(15, buffer, bufferIndex);
        bufferIndex += 4;
        // dataOffset = 40
        writeInt4(40, buffer, bufferIndex);
        bufferIndex += 4;
        // dataDisplacement = 0
        writeInt4(0, buffer, bufferIndex);
        bufferIndex += 4;
        // setupCount = 0 (1 byte + 1 padding byte)
        buffer[bufferIndex] = 0;
        buffer[bufferIndex + 1] = 0; // padding byte

        assertEquals(smbComNtTransaction.dataOffset, SmbComTransaction.readInt4(dst, 27), "dataOffset should be written correctly");
        assertEquals(smbComNtTransaction.dataDisplacement, SmbComTransaction.readInt4(dst, 31),
                "dataDisplacement should be written correctly");
        assertEquals(0, dst[35], "Reserved byte should be 0");
    }

    @Test
    void testWriteParameterWordsWireFormat_ZeroCounts() {

            return txn_buf;
        }

        int getParameterDisplacement() {
            return parameterDisplacement;
        }

        int getDataDisplacement() {
            return dataDisplacement;
        }

        int getParameterOffset() {
            return parameterOffset;
        }

        int getDataOffset() {
            return dataOffset;
        }

        bufferIndex += 4;
        dataCount = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        dataOffset = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        dataDisplacement = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        setupCount = buffer[bufferIndex] & 0xFF;
        bufferIndex += 2;
        if ((setupCount != 0) && (LogStream.level >= 3)) {

        dstIndex += 4;
        writeInt4(dataCount == 0 ? 0 : dataOffset, dst, dstIndex);
        dstIndex += 4;
        if (command == SMB_COM_NT_TRANSACT_SECONDARY) {
            writeInt4(dataDisplacement, dst, dstIndex);
            dstIndex += 4;
            dst[dstIndex++] = (byte) 0x00; // Reserved1
        } else {
            dst[dstIndex++] = (byte) setupCount;
            writeInt2(function, dst, dstIndex);

            this.dataOffset += this.pad2;

            this.dataDisplacement += this.dataCount;

            available -= this.pad2;
            this.dataCount = Math.min(this.totalDataCount - this.dataDisplacement, available);
        }
        if (this.parameterDisplacement + this.parameterCount >= this.totalParameterCount
                && this.dataDisplacement + this.dataCount >= this.totalDataCount) {

        // dataCount (4 bytes)
        SMBUtil.writeInt4(200, buffer, bufferIndex + 23);

        // dataOffset (4 bytes)
        SMBUtil.writeInt4(128, buffer, bufferIndex + 27);

        // dataDisplacement (4 bytes)
        SMBUtil.writeInt4(0, buffer, bufferIndex + 31);

        // setupCount (1 byte) + 1 reserved byte
        buffer[bufferIndex + 35] = 0x00; // setupCount = 0