assertEquals(SimpleCircuitBreaker.State.OPEN, circuitBreaker.getState());

        // Wait for timeout
        Thread.sleep(150);

        // Next call should transition to HALF_OPEN
        String result = circuitBreaker.call(() -> "success");
        assertEquals("success", result);
        assertEquals(SimpleCircuitBreaker.State.HALF_OPEN, circuitBreaker.getState());
    }

    @Test

            for (int state : disconnectedStates) {
                transport.setState(state);
                assertTrue(transport.isDisconnected(), "State " + state + " should be disconnected");
            }

            for (int state : connectedStates) {
                transport.setState(state);
                assertFalse(transport.isDisconnected(), "State " + state + " should not be disconnected");

        assertEquals(State.HALF_OPEN, circuitBreaker.getState(), "Circuit should be in HALF_OPEN");

        // One more success should close the circuit (threshold is 2)
        circuitBreaker.executeWithCircuitBreaker(() -> "success2");
        assertEquals(State.CLOSED, circuitBreaker.getState(), "Circuit should be CLOSED after success threshold");
    }

    @Test

		var throughputHighestResults []SpeedTestResult

		sendResult := func() {
			var result madmin.SpeedTestResult

			durationSecs := opts.duration.Seconds()

			result.GETStats.ThroughputPerSec = throughputHighestGet / uint64(durationSecs)
			result.GETStats.ObjectsPerSec = throughputHighestGet / uint64(opts.objectSize) / uint64(durationSecs)
			result.PUTStats.ThroughputPerSec = throughputHighestPut / uint64(durationSecs)

        channel1 = new ChannelInfo("channel1", mockTransport1, local, remote1);
        channel1.setState(ChannelState.ESTABLISHED);

        channel2 = new ChannelInfo("channel2", mockTransport2, local, remote2);
        channel2.setState(ChannelState.ESTABLISHED);
    }

    @Test
    void testSingleChannelSelection() {

			CollectedAt:   UTCNow(),
			InterfaceName: globalInternodeInterface,
		}
		netStats, err := net.GetInterfaceNetStats(globalInternodeInterface)
		if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v  (nicstats)", byHostName, err.Error()))
		} else {
			m.Aggregated.Net.NetStats = netStats
		}
	}
	if types.Contains(madmin.MetricsMem) {
		m.Aggregated.Mem = &madmin.MemMetrics{

            // Reconnect
            channel.setState(ChannelState.CONNECTING);
            // Connection would be ensured through proper transport interface

            // Re-establish channel binding
            manager.performChannelBinding(channel);

            // Update channel with new transport
            channel.setTransport(newTransport);
            channel.setState(ChannelState.ESTABLISHED);

        }

        // Should have some state
        AuthenticationRateLimiter.RateLimiterStats stats = rateLimiter.getStats();
        assertTrue(stats.getActiveAccounts() > 0);

        // Reset
        rateLimiter.reset();

        // State should be cleared
        stats = rateLimiter.getStats();
        assertEquals(0, stats.getTotalBlocked());
        assertEquals(0, stats.getAccountsLocked());

        });
    }

    @Test
    public void testStatistics() throws Exception {
        // Reset stats
        validator.resetStats();

        ServerResponseValidator.ValidationStats stats = validator.getStats();
        assertEquals(0, stats.getTotalValidations());
        assertEquals(0, stats.getFailedValidations());

        // Perform some validations
        try {

            assertEquals(address, connection.getRemoteAddress(), "Remote address should match");
            assertNotNull(connection.getState(), "Connection state should not be null");

            System.out.println("RDMA connection created to: " + address);
            System.out.println("Connection state: " + connection.getState());
        }
    }

    @Test
    public void testRdmaTransportCreationWithMockDelegate() throws Exception {