assertEquals(1, config.getChannelBindingPolicy(), "Default binding policy should be preferred");
        assertEquals("adaptive", config.getLoadBalancingStrategy(), "Default strategy should be adaptive");
        assertEquals(10, config.getChannelHealthCheckInterval(), "Default health check interval should be 10");
    }

    @Test

     */
    WEIGHTED_RANDOM,

    /**
     * Affinity-based selection for related operations
     */
    AFFINITY_BASED,

    /**
     * Adaptive selection based on operation type and performance
     */
    ADAPTIVE

     *
     * @param manager channel manager
     */
    public ChannelLoadBalancer(ChannelManager manager) {
        this.manager = manager;
        this.strategy = LoadBalancingStrategy.ADAPTIVE;
        this.roundRobinCounter = new AtomicInteger(0);
    }

    /**
     * Get current load balancing strategy
     *
     * @return current strategy
     */

        props.setProperty("jcifs.smb.client.useMultiChannel", "true");
        props.setProperty("jcifs.smb.client.maxChannels", "4");
        props.setProperty("jcifs.smb.client.loadBalancingStrategy", "adaptive");
        props.setProperty("jcifs.smb.client.channelHealthCheckInterval", "5");

        multiConfig = new PropertyConfiguration(props);

        // Mock context and session for ChannelManager

        when(mockConfig.getMaxChannels()).thenReturn(4);
        when(mockConfig.getChannelBindingPolicy()).thenReturn(1); // preferred
        when(mockConfig.getLoadBalancingStrategy()).thenReturn("adaptive");
        when(mockConfig.getChannelHealthCheckInterval()).thenReturn(10);

        channelManager = new ChannelManager(mockContext, mockSession);
    }

    @Test
    void testConstructor() {

        }
    }

    @Test
    void testAdaptiveStrategyLargeTransfer() throws Exception {
        loadBalancer.setStrategy(LoadBalancingStrategy.ADAPTIVE);

        Smb2ReadRequest largeRead = mock(Smb2ReadRequest.class);
        when(largeRead.getReadLength()).thenReturn(2 * 1024 * 1024); // 2MB