wordCount /= 2;
        dst[start] = (byte) (wordCount & 0xFF);

        byteCount = writeBytesWireFormat(dst, dstIndex + 2);
        dst[dstIndex] = (byte) (byteCount & 0xFF);
        dstIndex++;
        dst[dstIndex++] = (byte) (byteCount >> 8 & 0xFF);
        dstIndex += byteCount;

        /* Normally, without intervention everything would batch

        this.wordCount /= 2;
        dst[start] = (byte) (this.wordCount & 0xFF);

        this.byteCount = writeBytesWireFormat(dst, dstIndex + 2);
        dst[dstIndex] = (byte) (this.byteCount & 0xFF);
        dstIndex++;
        dst[dstIndex++] = (byte) (this.byteCount >> 8 & 0xFF);
        dstIndex += this.byteCount;

        /*
         * Normally, without intervention everything would batch

        assertTrue(result.contains("byteCount=8"));
        assertTrue(result.contains("oemDomainName=TEST_DOMAIN"));
    }

    // Helper method to set protected byteCount field using reflection
    private void setByteCount(SmbComNegotiateResponse response, int byteCount) {
        try {
            Field field = response.getClass().getSuperclass().getDeclaredField("byteCount");
            field.setAccessible(true);

        serverData.encryptionKeyLength = 8;
        response.byteCount = 15; // 8 bytes key + 6 bytes "DOMAIN" + 1 null terminator

        // Prepare byte array
        byte[] encryptionKey = "12345678".getBytes();
        byte[] domainNameBytes = "DOMAIN".getBytes(ServerMessageBlock.OEM_ENCODING);
        ByteBuffer buffer = ByteBuffer.allocate(response.byteCount);
        buffer.put(encryptionKey);
        buffer.put(domainNameBytes);

            }
            bufferIndex += wordCount * 2;
        }

        byteCount = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        if (byteCount != 0) {
            int n = readBytesWireFormat(buffer, bufferIndex);
            if ((n != byteCount) && (LogStream.level >= 5)) {
                log.println("byteCount=" + byteCount + " but readBytesWireFormat returned " + n);
            }

        }

        this.byteCount = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        if (this.byteCount != 0) {
            int n = readBytesWireFormat(buffer, bufferIndex);
            if ((n != this.byteCount) && log.isTraceEnabled()) {
                log.trace("byteCount=" + this.byteCount + " but readBytesWireFormat returned " + n);
            }

        private long totalBytesWritten = 0L;
        private boolean completed = false;

        @Override
        public void write(Buffer source, long byteCount) throws IOException {
          super.write(source, byteCount);
          totalBytesWritten += byteCount;
          progressListener.update(totalBytesWritten, contentLength(), completed);
        }

        @Override
        public void close() throws IOException {

        SMBUtil.writeInt2(83, buffer, 36); // andxOffset (33 + 50)
        SMBUtil.writeInt2(20, buffer, 42); // byteCount

        // Setup andx command data at offset 83 (absolute position from buffer start)
        buffer[83] = 2; // andx wordCount
        SMBUtil.writeInt2(10, buffer, 88); // andx byteCount

        int length = testBlock.decode(buffer, 0);

        assertTrue(length > 0);

        buf[1] = 0x66; // andxCommand
        ServerMessageBlock.writeInt2(50, buf, 3); // andxOffset
        ServerMessageBlock.writeInt2(20, buf, 9); // byteCount for main block

        // At offset 50, the implementation writes andx.wordCount (0) to buffer
        // Then reads byteCount at offset 51
        ServerMessageBlock.writeInt2(20, buf, 51);

        int n = block.readAndXWireFormat(buf, 0);
        assertTrue(n > 0);

            return wordCount * 2;
        }

        @Override
        int readBytesWireFormat(byte[] buffer, int bufferIndex) {
            System.arraycopy(buffer, bufferIndex, bytes, 0, byteCount);
            return byteCount;
        }
    }

    @BeforeEach
    void setUp() {
        smb = new TestServerMessageBlock();
    }

    @Test
    void testInt2ReadWrite() {
        byte[] buffer = new byte[2];