// Set disallowCompound
        config.disallowCompound = new HashSet<>(Arrays.asList("Command1", "Command2"));

        assertFalse(config.isAllowCompound("Command1"));
        assertFalse(config.isAllowCompound("Command2"));
        assertTrue(config.isAllowCompound("Command3"));
    }

    @Test
    @DisplayName("Test initResolverOrder with null/empty input")

    }

    /**
     * Executes an external command with the given parameters.
     * @param commands The command array to execute.
     * @param username The username parameter for the command.
     * @param password The password parameter for the command.
     * @return The exit code of the executed command.
     */
    protected int executeCommand(final String[] commands, final String username, final String password) {

    /**
     * Constructs an AndX message block with configuration and command
     * @param config the configuration
     * @param command the SMB command
     */
    protected AndXServerMessageBlock(final Configuration config, final byte command) {
        this(config, command, null);
    }

    /**
     * Constructs an AndX message block with command and chained command
     * @param config the configuration

import jakarta.annotation.PostConstruct;

/**
 * Query processor component that handles query filters and commands.
 * This class provides a pipeline for processing Lucene queries by applying
 * a chain of filters and executing registered query commands.
 *
 * <p>The processor maintains a map of query commands indexed by query class names
 * and a list of filters that are applied in order during query processing.</p>
 */

 * Tests for SMB connection batch limit functionality.
 * Tests the batch limit configuration for various SMB commands.
 */
public class SmbConnectionTest {

    /**
     * Test that getBatchLimit returns correct values for different commands
     */
    @Test
    @DisplayName("getBatchLimit returns correct values for different SMB commands")
    public void testBatchLimitForDifferentCommands() throws CIFSException {

     * @param mid the message ID to set
     */
    void setMid(long mid);

    /**
     * Gets the SMB command.
     *
     * @return the command
     */
    int getCommand();

    /**
     * Sets the SMB command.
     *
     * @param command the command to set
     */
    void setCommand(int command);

    /**
     * Sets the user ID.
     *
     * @param uid the user ID to set
     */

            super(config);
        }

        public TestServerMessageBlock(Configuration config, byte command) {
            super(config, command);
        }

        public TestServerMessageBlock(Configuration config, byte command, String path) {
            super(config, command, path);
        }

        @Override
        protected int writeParameterWordsWireFormat(byte[] dst, int dstIndex) {

    private byte[] b;

    SmbComWrite() {
        command = SMB_COM_WRITE;
    }

    SmbComWrite(final int fid, final int offset, final int remaining, final byte[] b, final int off, final int len) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        command = SMB_COM_WRITE;
    }

import jakarta.annotation.PostConstruct;

/**
 * Command-based thumbnail generator that executes external commands to create thumbnails.
 * Uses external tools through command execution to generate thumbnail images from documents.
 */
public class CommandGenerator extends BaseThumbnailGenerator {
    private static final Logger logger = LogManager.getLogger(CommandGenerator.class);

    /** List of command strings to execute for thumbnail generation. */

        dataLength = len;
        digest = null; /* otherwise recycled commands
                        * like writeandx will choke if session
                        * closes in between */
    }

    @Override
    int getBatchLimit(final byte command) {
        if (command == SMB_COM_READ_ANDX) {
            return READ_ANDX_BATCH_LIMIT;
        }
        if (command == SMB_COM_CLOSE) {
            return CLOSE_BATCH_LIMIT;
        }