* @param i the integer value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (4)
     */
    public static int enc_uint32be(final int i, final byte[] dst, int di) {
        dst[di] = (byte) (i >> 24 & 0xFF);
        di++;
        dst[di++] = (byte) (i >> 16 & 0xFF);
        dst[di++] = (byte) (i >> 8 & 0xFF);

        assertEquals((byte) 0x56, dst[1]);
        assertEquals((byte) 0x34, dst[2]);
        assertEquals((byte) 0x12, dst[3]);

        // Test with max value for 4 bytes
        SMBUtil.writeInt4(0xFFFFFFFFL, dst, 4);
        assertEquals((byte) 0xFF, dst[4]);
        assertEquals((byte) 0xFF, dst[5]);
        assertEquals((byte) 0xFF, dst[6]);
        assertEquals((byte) 0xFF, dst[7]);

        Encodable enc = new ByteEncodable(src, 5, 0); // zero length
        byte[] dst = new byte[8];
        Arrays.fill(dst, (byte) 0x7A);

        int written = enc.encode(dst, 3);

        assertEquals(0, enc.size(), "size() must be zero");
        assertEquals(0, written, "encode() must return zero for zero length");
        for (byte b : dst) {
            assertEquals((byte) 0x7A, b, "Destination should remain unchanged");
        }

    protected int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        if (this.getCommand() != SMB_COM_NT_TRANSACT_SECONDARY) {
            dst[dstIndex++] = this.maxSetupCount;
        } else {
            dst[dstIndex++] = (byte) 0x00; // Reserved
        }
        dst[dstIndex] = (byte) 0x00; // Reserved
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00; // Reserved

        smbComOpenAndX = new SmbComOpenAndX(fileName, access, 0, andx);
        // Buffer needs 26 bytes: 2+2+2+2+4+2+4+8 = 26
        byte[] dst = new byte[26];
        int result = smbComOpenAndX.writeParameterWordsWireFormat(dst, 0);
        assertEquals(26, result);
    }

    /**
     * Test writeBytesWireFormat method with Unicode.
     */
    @Test

        dstIndex += 4;
        if (this.blob != null) {
            SMBUtil.writeInt2(this.blob.length, dst, dstIndex);
        } else {
            SMBUtil.writeInt2(this.lmHash.length, dst, dstIndex);
            dstIndex += 2;
            SMBUtil.writeInt2(this.ntHash.length, dst, dstIndex);
        }
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00;

        // Test the writing of bytes to a byte array
        byte[] dst = new byte[100];
        int bytesWritten = smbComQueryInformation.writeBytesWireFormat(dst, 0);

        // Expected format: buffer format (1 byte) + file name (null-terminated)
        int expectedLength = 1 + TEST_FILE_NAME.length() + 1;
        assertEquals(expectedLength, bytesWritten);
        assertEquals(0x04, dst[0]); // Buffer format

    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(path, dst, dstIndex);

        return dstIndex - start;
    }

    @Override

	TableType(dst interface{}) (TableType, error)

	// Columns
	AddColumn(dst interface{}, field string) error
	DropColumn(dst interface{}, field string) error
	AlterColumn(dst interface{}, field string) error
	MigrateColumn(dst interface{}, field *schema.Field, columnType ColumnType) error
	// MigrateColumnUnique migrate column's UNIQUE constraint, it's part of MigrateColumn.

        expected[directoryName.length() + 1] = 0x00; // Null terminator

        byte[] dst = new byte[100];
        int bytesWritten = smbCom.writeBytesWireFormat(dst, 0);

        assertEquals(expected.length, bytesWritten, "Number of bytes written should match expected length.");

        byte[] actual = new byte[bytesWritten];
        System.arraycopy(dst, 0, actual, 0, bytesWritten);

        // Use assertArrayEquals for byte array comparison