PropertyConfiguration config = new PropertyConfiguration(props);
        assertFalse(config.isUseMultiChannel());

        props.setProperty("jcifs.smb.client.useMultiChannel", "true");
        config = new PropertyConfiguration(props);
        assertTrue(config.isUseMultiChannel());
    }

    @Test
    void testMaxChannelsProperty() throws CIFSException {
        Properties props = new Properties();

        assertNotNull(channelManager);
        assertFalse(channelManager.isUseMultiChannel());
        assertEquals(0, channelManager.getChannels().size());
        assertNotNull(channelManager.getLoadBalancer());
    }

    @Test
    void testInitializationWithoutMultiChannelSupport() throws IOException {
        when(mockConfig.isUseMultiChannel()).thenReturn(false);

        return this.delegate.getHandleReconnectRetries();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isUseMultiChannel()
     */
    @Override
    public boolean isUseMultiChannel() {
        return this.delegate.isUseMultiChannel();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#getMaxChannels()
     */
    @Override

        });
    }

    /**
     * Check if multi-channel is enabled
     *
     * @return true if multi-channel is enabled
     */
    public boolean isUseMultiChannel() {
        return channelManager != null && channelManager.isUseMultiChannel();
    }

    /**
     * Get the channel manager
     *
     * @return channel manager instance
     */

        }
    }

    /**
     * Check if multi-channel is enabled
     *
     * @return true if enabled
     */
    public boolean isUseMultiChannel() {
        return multiChannelEnabled;
    }

    /**
     * Get the load balancer
     *
     * @return load balancer instance
     */
    public ChannelLoadBalancer getLoadBalancer() {

        // Test that ChannelManager initializes properly
        assertNotNull(channelManager);
        assertNotNull(channelManager.getChannels());
        // Note: isUseMultiChannel() checks if actual multi-channel is negotiated with server
        // In mock environment, this will be false until we mock successful negotiation

        // Verify load balancer is initialized

private boolean multiChannelSupported;

public void negotiateMultiChannel() throws IOException {
    // Check if both client and server support multi-channel
    if (!context.getConfig().isUseMultiChannel()) {
        return;
    }
    
    if (!serverCapabilities.contains(SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
        log.debug("Server does not support multi-channel");
        return;
    }
    

    public String getHandleStateDirectory() {
        return this.handleStateDirectory;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isUseMultiChannel()
     */
    @Override
    public boolean isUseMultiChannel() {
        return this.useMultiChannel;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#getMaxChannels()
     */
    @Override

     * Enable SMB3 Multi-Channel support
     *
     * Property {@code jcifs.smb.client.useMultiChannel} (boolean, default true)
     *
     * @return whether multi-channel is enabled
     */
    boolean isUseMultiChannel();

    /**
     * Maximum number of channels per session
     *
     * Property {@code jcifs.smb.client.maxChannels} (int, default 4)
     *
     * @return maximum channels per session
     */