}

  @Test
  fun testHttp(socketMode: SocketMode = burstValues(Channel, Standard)) {
    testConnection(socketMode)
  }

  @Test
  fun testHttps(
    provider: Provider = Provider.JSSE,
    protocol: Protocol = burstValues(HTTP_1_1, HTTP_2),
    tlsVersion: TlsVersion = burstValues(TLS_1_3, TLS_1_2),
    socketMode: SocketMode = burstValues(Channel, Standard),

/**
 * Load balancing strategies for multi-channel connections
 */
public enum LoadBalancingStrategy {
    /**
     * Round-robin selection through available channels
     */
    ROUND_ROBIN,

    /**
     * Select the least busy channel based on pending operations
     */
    LEAST_LOADED,

    /**
     * Weighted random selection based on channel scores
     */
    WEIGHTED_RANDOM,

    /**

    /**
     * Channel binding in progress
     */
    BINDING(4),

    /**
     * Channel is actively transferring data
     */
    ACTIVE(5),

    /**
     * Channel connection has failed
     */
    FAILED(6),

    /**
     * Channel is being closed
     */
    CLOSING(7);

    private final int value;

    ChannelState(int value) {
        this.value = value;
    }

     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1
     * Used in SMB2 READ and WRITE requests to indicate RDMA channel
     */
    public static final int SMB2_CHANNEL_RDMA_V1 = 0x00000001;

    /**
     * SMB2 Channel constant for RDMA V1 invalidate
     * Used to indicate RDMA with invalidation
     */

func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after
// the last sent value is received. After the last value has been received
// from a closed channel c, any receive from c will succeed without

use a synchronization mechanism such as a lock or channel
communication to establish a relative ordering.
</p>

<h3 id="chan">Channel communication</h3>

<p>
Channel communication is the main method of synchronization
between goroutines.  Each send on a particular channel
is matched to a corresponding receive from that channel,
usually in a different goroutine.
</p>

<p class="rule">

        this.rdmaChannelInfo = new RdmaChannelInfo(remoteKey, address, length);
        this.channel = Smb2Constants.SMB2_CHANNEL_RDMA_V1;
    }

    /**
     * Get RDMA channel information
     *
     * @return RDMA channel info, or null if not using RDMA
     */
    public RdmaChannelInfo getRdmaChannelInfo() {
        return rdmaChannelInfo;
    }

    /**

	// Close when we reach 0
	globalServiceFreezeCnt--
	if globalServiceFreezeCnt <= 0 {
		// Set to a nil channel.
		var _ch chan struct{}
		if val := globalServiceFreeze.Swap(_ch); val != nil {
			if ch, ok := val.(chan struct{}); ok && ch != nil {
				// Close previous non-nil channel.
				xioutil.SafeClose(ch)
			}
		}
		globalServiceFreezeCnt = 0 // Don't risk going negative.
	}

type Stream struct {
	// responses from the remote server.
	// Channel will be closed after error or when remote closes.
	// All responses *must* be read by the caller until either an error is returned or the channel is closed.
	// Canceling the context will cause the context cancellation error to be returned.
	responses <-chan Response
	cancel    context.CancelCauseFunc

	// Requests sent to the server.

                        // Handle potential multi-channel failure
                        if (isUseMultiChannel() && trans != this.transport) {
                            ChannelInfo channel = channelManager.getChannelForTransport(trans);
                            if (channel != null) {
                                channelManager.handleChannelFailure(channel, e);
                                // Retry with primary transport