}
        } else {
            this.openFunction = OPEN_FN_OPEN;
        }
    }

    @Override
    protected int getBatchLimit(final Configuration cfg, final byte cmd) {
        return cmd == SMB_COM_READ_ANDX ? cfg.getBatchLimit("OpenAndX.ReadAndX") : 0;
    }

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

            mockConfig.getListCount();
            mockConfig.getListSize();
            mockConfig.getAttributeCacheTimeout();
            mockConfig.isIgnoreCopyToException();
            mockConfig.getBatchLimit("cmd");
            mockConfig.getNotifyBufferSize();
            mockConfig.getMaxRequestRetries();
            mockConfig.isStrictResourceLifecycle();
            mockConfig.isTraceResourceUsage();

    }

    AndXServerMessageBlock(final ServerMessageBlock andx) {
        if (andx != null) {
            this.andx = andx;
            andxCommand = andx.command;
        }
    }

    int getBatchLimit(final byte command) {
        /* the default limit is 0 batched messages before this
         * one, meaning this message cannot be batched.
         */
        return 0;
    }

    /*

        return this.delegate.isIgnoreCopyToException();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#getBatchLimit(java.lang.String)
     */
    @Override
    public int getBatchLimit(final String cmd) {
        return this.delegate.getBatchLimit(cmd);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isAllowCompound(java.lang.String)
     */

        // Given
        String operation = "TestOperation";
        when(mockDelegate.getBatchLimit(operation)).thenReturn(100);

        // When
        int batchLimit = delegatingConfig.getBatchLimit(operation);

        // Then
        assertEquals(100, batchLimit, "Should delegate batch limit");
        verify(mockDelegate).getBatchLimit(operation);
    }

    @Test

    void setParam(final int fid, final long offset, final int maxCount) {
        this.fid = fid;
        this.offset = offset;
        this.maxCount = minCount = maxCount;
    }

    @Override
    int getBatchLimit(final byte command) {
        return command == SMB_COM_CLOSE ? BATCH_LIMIT : 0;
    }

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

        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;
        }

        super(andx);
        this.session = session;
        this.path = path;
        this.service = service;
        command = SMB_COM_TREE_CONNECT_ANDX;
    }

    @Override
    int getBatchLimit(final byte command) {
        final int c = command & 0xFF;
        // why isn't this just return batchLimits[c]?
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return batchLimits[0];

    }

    /**
     * Gets the batch limit for chained commands
     * @param cfg the configuration
     * @param cmd the command byte
     * @return the batch limit
     */
    protected int getBatchLimit(final Configuration cfg, final byte cmd) {
        /*
         * the default limit is 0 batched messages before this
         * one, meaning this message cannot be batched.
         */
        return 0;
    }

            }
            primaryDomain = auth.domain.toUpperCase();
        } else {
            throw new SmbException("Unsupported");
        }
    }

    @Override
    int getBatchLimit(final byte command) {
        return command == SMB_COM_TREE_CONNECT_ANDX ? BATCH_LIMIT : 0;
    }

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